最难算法
1. 史上最难的数学题，大家来算一算啊 有3个人去投宿,一晚30元.三个人每人掏了10元凑够30元交给了
这个推理其实也是偷换概念。意义是想把人带进3人各花10元的陷阱。3人各花10元=30元，老板退还5元=25元+服务生偷藏2元=27元。退回每人一元即每人交9元 3人*9元=27元。即3人花的钱就是27元，老板加服务生拿的钱也是27元。推理误导在于想误导每人花10元。但其实每人只花了9元住店。即3人共用27元。那服务生拿走的两元不能加进顾客的钱里。
真实算式应为：顾客部分：3人各交10元=30元 老板退费后各拿一元即每人交9元=27元。
老板部分：收30元后退5元=25元 服务生拿走2元=27元（这里设计服务生是老板方面的人。不算顾客。）
交的等于老板方面收的。钱数是对的。服务生的两元应该算在老板方面，不在顾客方面
//我做出来了。
//输入：A1,A3,A2,A8,A7,A6,A5,A4
//输出：A1,A2,A3,A4,A5,A6,A7,A8
//只是对输入的字串长度限制在100以内。
#include "stdio.h"
int main( )
{
char str1[100];
//输入字符串
printf("请输入字符串：");
scanf("%s",str1);
//对字符串分组
char str[50][3];
char *p=str1;
int i=0,j=0;
for(;*p!='\0';p++)
{
if(*p!=',')
{
str[i][j]=*p;
j++;
}
else
{
str[i][j]='\0';
i++;
j=0;
}
}
str[i][j]='\0';
i++;
j=0;
//对字串排序
for(j=0;j<i;j++)
for(int k=j+1;k<i;k++)
{
if(str[j][1]>str[k][1])
{
char temp;
temp=str[j][0];
str[j][0]=str[k][0];
str[k][0]=temp;
temp=str[j][1];
str[j][1]=str[k][1];
str[k][1]=temp;
}
}
//复制排序好的字串
p=str1;
for(j=0;j<i;j++)
{
*p=str[j][0];
p++;
*p=str[j][1];
p++;
if(j<i-1)
{
*p=',';
p++;
}
}
*p='\0';
//输出排序好的字串
printf("排序后的符串：%s",str1);
printf("\n");
}
3. 算法和建模最难的是思想还是技术
你可以先去【绘学霸】网站找“3d建模”板块的【免费】视频教程-【点击进入】完整入门到精通视频教程列表： www.huixueba.net/web/AppWebClient/AllCourseAndResourcePage?type=1&tagid=307&zdhhr-11y04r-373843074936449404
想要系统的学习可以考虑报一个网络直播课，推荐CGWANG的网络课。老师讲得细，上完还可以回看，还有同类型录播课可以免费学（赠送终身VIP）。
自制能力相对较弱的话，建议还是去好点的培训机构，实力和规模在国内排名前几的大机构，推荐行业龙头：王氏教育。
王氏教育全国直营校区面授课程试听【复制后面链接在浏览器也可打开】： www.huixueba.com.cn/school/3dmodel?type=2&zdhhr-11y04r-373843074936449404
在“3d建模”领域的培训机构里，【王氏教育】是国内的老大，且没有加盟分校，都是总部直营的连锁校区。跟很多其它同类型大机构不一样的是：王氏教育每个校区都是实体面授，老师是手把手教，而且有专门的班主任从早盯到晚，爆肝式的学习模式，提升会很快，特别适合基础差的学生。
大家可以先把【绘学霸】APP下载到自己手机，方便碎片时间学习——绘学霸APP下载： www.huixueba.com.cn/Scripts/download.html
4. 世界上最难的数学题到底是什么
费马最后定理
对于任意不小于3的正整数 ,x^n + y^n = z ^n 无正整数解
哥德巴赫猜想
对于任一大于2的偶数都可写成两个质数之和，即1+1问题
NP完全问题
是否存在一个确定性算法，可以在多项式时间内，直接算出或是搜寻出正确的答案呢？这就是着名的NP=P？的猜想
霍奇猜想
霍奇猜想断言，对于所谓射影代数簇这种特别完美的空间类型来说，称作霍奇闭链的部件实际上是称作代数闭链的几何部件的(有理线性)组合
庞加莱猜想
庞加莱已经知道，二维球面本质上可由单连通性来刻画，他提出三维球面(四维空间中与原点有单位距离的点的全体)的对应问题
黎曼假设
德国数学家黎曼(1826~1866)观察到，素数的频率紧密相关于一个精心构造的所谓黎曼zeta函数ζ(s)的性态。着名的黎曼假设断言，方程ζ(s)=0的所有有意义的解都在一条直线上
杨－米尔斯存在性和质量缺口
纳卫尔-斯托可方程的存在性与光滑性
BSD猜想
像楼下说的1+1=2 并不是什么问题的简称 而就是根据皮亚诺定理得到的一个加法的基本应用，是可以简单通过皮亚诺定理和自然数公理解决的
5. 求24最难算法。
5 5 5 1
5（5-1/5）= 24
6. 世界上最复杂的程序算法有哪些
Jump-pointer: 在作LA(v,d)的时候, 如果一层一层的往上搜索很慢. 有没有可能直接跳呢? 比如我们知道LA(u,d) = LA(v,d),如果u是v的一个ancestor. 如果直接储存了LA(u,d), 并且可以在log(n)的时间"跳"到u, 那么只要log n的时间就能找到LA(v,d). 这个算法要用 O(n log n)的preprocess time + O(log n)的time. 每一次跳的距离是上一次的1/2倍.，[这个算法很简单的]。
7. 史上最难的算24点，等待高人破解！
24点一般只考虑加减乘除，不考虑开方和乘方。如果不要求速度的话，24点不存在难题。
一共四个数，设为ABCD。那么24点的公式只有两种情况。
1.3-1型：（）@ X或者X@（）
其中X表示任意一个数，@表示任意一种算法，（）内表示剩下三个数的任意组合。
比如A+B+C+D，A÷（B+C÷D），
2.2-2型：（）#（）
其中（）表示任意两个数的乘积或商，#表示加或减
比如A×B+C×D
或者（）表示两个数的和或差，#表示乘或除
比如（A+B）×（C-D）
事实上，4个数中，不同的两个数的组合只有三种，而且2-2型几乎不会涉及到分数。所以2-2型实际上非常容易观察得出，比如2，4，6，10的答案是（2+10）×（6-4）
而3-1型比较复杂，有些题会算很长时间
显然，1，1，2，12这种题我们一眼就能看出来，所以拿到题目时，我们先快速观察一下是不是较简单的题，或者是2-2型的题，很多题往往就解决了。问题是碰到了答案比较隐蔽的，或者是涉及到分数的，比如4，6，6，10该怎么解决。
首先，通过最开始的观察我们已经确定了不是2-2型，那么一定就是3-1型。那么我们可以把这个“1”提出来，假设是4，那么只有以下五种可能，4+20，28-4，4×6，96÷4，4÷1/6
于是我们就看剩下的三个数能不能凑成20，28，6，96，1/6就可以了。因为只有三个数，这个过程是很快的，但是头脑一定要保持清晰，不要因为简单就误算。
验算后很显然6×（10+6）=96，如果你没有发现，我们再验算6，
那么剩下的三个数只需要组成4，18，30，1/4，144就可以了，稍微观察一下便知4÷（6+10）=1/4
那么最终答案就是6÷（4÷（6+10））=24
当然有些题只有一种答案，错过了一种，就必须重新验算了。
而其中也有一些方法，比如4，6，10显然不能组成144，因为4×6×10才等于144的一半还不到，如果在中间添加加减除那么数字肯定不够大，当然，这些方法需要自己总结，积累经验。
再看1，5，5，5这道题就比较简单了，因为只有两种数字，而且1显然不是“1”，所以只需要验证5就可以，那么剩下的1，5，5需要组合成，5/24，24/5，19，29，120其中之一。
简单计算一下，不难发现5-1/5=24/5
于是5×（5-1/5）=24
相对而言4，6，6，10就比较难，因为有三种数字，而且涉及到分数。
而2，7，8，9虽然有四种数字，但是计算的时候并没有那么复杂。
比如验算7的时候，需要剩下的三个数组成168，17，7/24，24/7，31。
很显然7/24和24/7不用考虑，因为剩下三个数不可能同时组成7和24，168很显然也不可能，因为把剩下三个数乘起来也没有168。当然了，这种经验式的判断需要你多加练习。
那么最终我们会发现这组数的“1”是8，答案是
2×（7+9）-8
任何一个题目，用这种方法算，一定可以算出来，如果你足够熟练的话，根本没有难题。所以说算24点考验的是你的熟练度而不是智商，当然也没有所谓的“史上最难”了。
8. 【比较难写的算法】最坏情况线性时间的选择
实际上比平均情况下线性时间的选择要复杂很多（算法导论上伪代码都没有）
问题是快速排序要求枢纽元在最后一个，如果采用hoare的划分算法，就没有这个要求。而给出的是枢纽元的值，然后要找到位置（搜索一遍），再交换。
如果采用hoare划分法，不用搜索，不过算法和书上描述的就稍有不同了。
另外，因为代码复杂，所以对于随机输入，此算法较慢
下面是hoare划分的选择代码
# include <ctime>
# include <cstdlib>
# include <iostream>
inline void swap(int &x, int&y)
{
int temp = x;
x = y;
y = temp;
}
// A[p..r]
int hoarePartitionX(int *A, int p, int r, int x)
{
int i = p - 1;
int j = r + 1;
for(;;)
{
while( A[--j] > x)
;
while( A[++i] < x)
;
if(i<j)
{
swap(A[i], A[j]);
}
else
{
return j;
}
}
}
// A[0..size-1]
void insertionSort(int *A, int size)
{
int i;
int key;
for(int j=1; j<size; j+=1)
{
key = A[j];
i = j - 1;
while(i >= 0 && A[i] > key)
{
A[i+1] = A[i];
i -= 1;
}
A[i+1] = key;
}
}
// return the ith smallest element of A[p..r]
int select(int *A, int p, int r, int i)
{
if(p == r) // only one element, just return
{
return A[p];
}
// #1. groupNum & rest
int groupNum = (r - p + 1) / 5; // not counting the rest
int rest = (r - p + 1) % 5;
// #2. sort the groups
for(int t=0; t<groupNum; t+=1)
{
insertionSort(A + p + t*5, 5);
}
if(rest != 0)
{
insertionSort(A + p + groupNum * 5, rest);
}
// #3. get the mid value x
int *mids;
if(rest == 0)
mids = new int[groupNum];
else
mids = new int[groupNum+1];
for(int t=0; t<groupNum; t+=1)
{
mids[t] = A[ p + t*5 + 2 ];
}
if(rest != 0)
{
mids[groupNum] = A[ p + groupNum*5 + (rest-1)/2 ];
}
int x;
if( rest == 0 )
{
x = select(mids, 0, groupNum-1, (groupNum-1) / 2 + 1);
}
else
{
x = select(mids, 0, groupNum, groupNum / 2 + 1);
}
delete []mids;
// #4. partition with x
int k = hoarePartitionX(A, p, r, x) - p + 1; // so the value A[p+k-1] is the kth smallest
// #5.
if(i <= k)
{
return select(A, p, p+k-1, i);
}
else
{
return select(A, p+k, r, i-k);
}
}
int main()
{
int array[100];
for(int i=0; i<100; i+=1)
array[i] = i;
for(int i=0; i<100; i+=1)
{
int rnd = rand()%100;
swap(array[0], array[rnd]);
}
std::cout << select(array, 0, 99, 82);
std::cin.get();
return 0;
}