今天晚自习机房刷题，有一道题最终WA掉两组，极其不爽，晚上回家补完作业欣然搞定它，特意来写篇博文来记录下
（最想吐槽的是这个叫做分治的分类，里面的题目真的需要分治吗。。。）
先来说下分治法
分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
三、分治法适用的情况
分治法所能解决的问题一般具有以下几个特征：
1) 该问题的规模缩小到一定的程度就可以容易地解决
2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；
4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；
第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；、
第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。
第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。
依据分治法设计程序时的思维过程
实际上就是类似于数学归纳法，找到解决本问题的求解方程公式，然后根据方程公式设计递归程序。
1、一定是先找到最小问题规模时的求解方法
2、然后考虑随着问题规模增大时的求解方法
3、找到求解的递归函数式后（各种规模或因子），设计递归程序即可。
网上和书上学了下，然而你丫做题基本用不大着，也是令我非常无奈
下面是题目。。。。
一、输出前k大的数
7617:输出前k大的数
总时间限制: 10000ms 单个测试点时间限制: 1000ms 内存限制: 65536kB
描述
给定一个数组，统计前k大的数并且把这k个数从大到小输出。
输入
第一行包含一个整数n，表示数组的大小。n < 100000。
第二行包含n个整数，表示数组的元素，整数之间以一个空格分开。每个整数的绝对值不超过100000000。
第三行包含一个整数k。k < n。
输出
从大到小输出前k大的数，每个数一行。
样例输入
10
4 5 6 9 8 7 1 2 3 0
5
样例输出
9
8
7
6
5
然而此题略蛋疼，表示C++党一个sort轻松+愉快
于是就有代码。。。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[100000]={0};
int main()
{
int n,m;
cin>>n;
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
sort(a+1,a+n+1);
cin>>m;
for (int i=n;i>=n-m+1;i--)
cout<<a[i]<<endl;
//printf("%d ",&a[i]);
return 0;
} 此题不解释
二、区间合并
这个题好像排序也解决了。。。表示我不禁想吐槽了
代码（这个题一开始智商被压制了。。。有点略蠢）
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct data{
int head,tail;
};
data qj[50010]={0};
int cmp(data x,data y)
{
if (x.head<y.head)
return 1;
else
if (x.head==y.head)
if (x.tail<=y.tail)
return 1;
else
return 0;
else
return 0;
}
int main()
{
int n;
bool f=false;
int start=0,end=0;//如果可以合并，开头和结尾
scanf("%d",&n);
int i,j;
for (i=1;i<=n;i++)
{
scanf("%d%d",&qj[i].head,&qj[i].tail);
end=max(end,qj[i].tail);//表示结尾的取所有区间的结尾的最大值
}
sort(qj+1,qj+n+1,cmp);//按照区间的开头进行排序，从小到大，一样则结尾从小到大排序
start=qj[1].head;//表示开头的为最小的那个
int h=qj[1].head,t=qj[1].tail;//为下文判断是否可以合并做准备
for (i=2;i<=n;i++)
if (qj[i].head>t)//因为有序，满足这个就不能合并
{f=true;break;}
else
t=max(t,qj[i].tail); //两个合并后，把当前最大的结尾记录，为以后对比做铺垫
if (!f)
printf("%d %d",start,end);
else
printf("no");
return 0;
}三、求排列的逆序数
逆序数，及排列中的逆序对的个数，此处用的归并排序，对归并排序进行一个计数的操作即可实现（终于正常的用了次分治，着实不易啊）
7622:求排列的逆序数
总时间限制: 1000ms 内存限制: 65536kB
描述
在Internet上的搜索引擎经常需要对信息进行比较，比如可以通过某个人对一些事物的排名来估计他（或她）对各种不同信息的兴趣，从而实现个性化的服务。
对于不同的排名结果可以用逆序来评价它们之间的差异。考虑1,2,…,n的排列i1，i2，…，in，如果其中存在j,k，满足 j < k 且 ij > ik， 那么就称(ij,ik)是这个排列的一个逆序。
一个排列含有逆序的个数称为这个排列的逆序数。例如排列 263451 含有8个逆序(2,1),(6,3),(6,4),(6,5),(6,1),(3,1),(4,1),(5,1)，因此该排列的逆序数就是8。显然，由1,2,…,n 构成的所有n!个排列中，最小的逆序数是0，对应的排列就是1,2,…,n；最大的逆序数是n(n-1)/2，对应的排列就是n,(n-1),…,2,1。逆序数越大的排列与原始排列的差异度就越大。
现给定1,2,…,n的一个排列，求它的逆序数。
输入
第一行是一个整数n，表示该排列有n个数（n <= 100000)。
第二行是n个不同的正整数，之间以空格隔开，表示该排列。
输出
输出该排列的逆序数。
样例输入
6
2 6 3 4 5 1
样例输出
8
提示
1. 利用二分归并排序算法（分治）；
2. 注意结果可能超过int的范围，需要用long long存储。
此处稍提一下归并排序
归并排序的基本思想
将待排序序列R[0…n-1]看成是n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序序列再次归并，得到n/4个长度为4的有序序列；如此反复进行下去，最后得到一个长度为n的有序序列。
综上可知：
归并排序其实要做两件事：
（1）“分解”——将序列每次折半划分。
（2）“合并”——将划分后的序列段两两合并后排序。
这道题在归并时记一个数就可以，具体的可以证明，但就不多提了
代码：
#include<iostream>
#include<cstdio>
using namespace std;
int a[100010]={0},L[100010]={0},R[100010]={0};
long long ans=0;
#define M 1000000000;
void gb(int left,int mid,int right)
{
int ll=mid-left+1;
int lr=right-mid;
for (int i=1;i<=ll;i++)
L[i]=a[left+i-1];//此操作方便处理
for (int i=1;i<=lr;i++)
R[i]=a[mid+i];
L[ll+1]=M;//将最后一个赋给一个极大值，可以当作一个“哨兵”非常的精妙，然而经测试似乎不加这条语句会出错
R[lr+1]=M;
int l=1,r=1;
for (int i=left; i<=right; i++)
{
if (L[l]<=R[r])
{
a[i]=L[l];
l++;
}
else
{
a[i]=R[r];
r++;
ans+=ll-l+1;//求逆序对的唯一多出来的语句
}
}
}
void gbsort(int left,int right)
{
int mid=(left+right)/2;
if (left<right)
{
gbsort(left,mid);//不断分治
gbsort(mid+1,right);
gb(left,mid,right);
}
}
int main()
{
int n;
scanf("%d",&n);
for (int i=1; i<=n; i++)
scanf("%d",&a[i]);
gbsort(1,n);
printf("%lld",ans);
return 0;
}四、一元三次方程求解
然而第一眼看到这个题其实我是拒绝的，有想过用求根公式，然而本人数学并不是非常好（当然也不是很差）表示求根公式和数学求法非常神，表示理解还不如二分查找答案多编几行代码快，于是开始二分
PS：此处鸣谢聪哥的数学指引
7891:一元三次方程求解
总时间限制: 1000ms 内存限制: 65536kB
描述
有形如：ax3+bx2+cx+d=0 这样的一个一元三次方程。
给出该方程中各项的系数(a，b，c，d 均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值>=1。要求由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点后2位。
输入
一行，包含四个实数a，b，c，d，相邻两个数之间用单个空格隔开。
输出
一行，包含三个实数，为该方程的三个实根，按从小到大顺序排列，相邻两个数之间用单个空格隔开，精确到小数点后2位。
样例输入
1.0 -5.0 -4.0 20.0
样例输出
-2.00 2.00 5.00
提示
记方程f(x)=0，若存在2个数x1和x2，且x1（此处题目应该是残了。。。）（请无视）
闲话不多说上代码吧，这个题也没什么好扯的。。。
#include<cstdio>
#include<cmath>
using namespace std;
double a,b,c,d;
double f(double x)
{
return a*x*x*x+b*x*x+c*x+d;
}
double search(double left,double right)
{
double mid=(left+right)/2;
if (right-left<1e-4) return mid;
else
{
if (f(mid)==0) return mid;
else if (f(left)*f(mid)<0) return search(left,mid);
else return search(mid,right);
}
}
int main()
{
double x1,x2;
scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
if (a<0)
{
a=-a;b=-b;c=-c;d=-d;
}
x1=(-2*b-sqrt(4*b*b-12*a*c))/(a*6);
x2=(-2*b+sqrt(4*b*b-12*a*c))/(a*6);
double ans1,ans2,ans3;
ans1=search(-101,x1);
ans2=search(x1,x2);
ans3=search(x2,101);
printf("%.2f %.2f %.2f",ans1,ans2,ans3);
return 0;
}五、统计数字
第一眼看题，以为是随便一个桶排就出来了，后来一看数据范围就呵呵了，不过这个题着实还是不难，然而还没有离散化难呢，那怕个什么啊，水量仅次第一题的存在，排个序，统计个数一波输出，一波带走
然而我蛋神@tyc0520居然一开始不会编，表示莫名奇妙，先跪一发
7909:统计数字
总时间限制: 1000ms 内存限制: 65536kB
描述
某次科研调查时得到了n个自然数，每个数均不超过1500000000（1.5*109）。已知不相同的数不超过10000个，现在需要统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。
输入
包含n+1行:
第一行是整数n，表示自然数的个数；
第2~n+1每行一个自然数。
40%的数据满足：1<=n<=1000；
80%的数据满足：1<=n<=50000；
100%的数据满足：1<=n<=200000，每个数均不超过1500 000 000（1.5*10^9）。
输出
包含m行（m为n个自然数中不相同数的个数），按照自然数从小到大的顺序输出。每行输出两个整数，分别是自然数和该数出现的次数，其间用一个空格隔开。
样例输入
8
2
4
2
4
5
100
2
100
样例输出
2 3
4 2
5 1
100 2
下面是代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[200010]={0};
int main()
{
int n;
scanf("%d",&n);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
sort(a+1,a+n+1);
int sum=0;
for (int i=1;i<=n;i++)
{
sum++;
if (a[i]==a[i+1])
continue;
else
{
printf("%d %d
",a[i],sum);
sum=0;
}
}
return 0;
} 好了，时间不早了，洗睡去了，表示前路漫漫，仍须努力啊