【备战蓝桥杯】USACO--> Milking Cows[2]

题目网址：http://wikioi.com/problem/1385/

昨天由于家里有点事情，就没有继续忙了。其实昨天上午已经按照我自己的思路把代码写出来了。可惜结果总有两个不能ac了。

后来参考了相关思路，发现自己思考问题的时候，太过拘谨。不过也可以理解，因为我本身对排序算法就不是很熟悉，总觉得像快速排序里面有递归调用就会很慢。

其实不是这样。后来写出的算法，明显比自己之前想象的算法要快一倍，而且思路清晰，容易调试。

果然，到了真正比赛的时候，还是写思路清晰的算法比较好。一是好调试错误。二是未必会慢。

这个是我自己设想的算法，一个是实现起来繁琐。情况复杂。前后融合都要考虑，二是，写到后面发现，还是要借助排序。因为再不排序，又会复杂，成指数级= =。

/*

300---------1000
700-------1200
1500---------2100

2000 2700
1、第一个组合与所有匹配，能融合，就融合，并标记融合过的；
2、产生的新组合与剩下的未标记的融合，同上；
3、该组合不能再融合时，从下一个未标记的开始搜索融合；
4、下一个标记的不能融合时候，再下一个；
5、所有都标记上了，结束。选出最长时间与最短时间

*/
#include <stdio.h>
#include <stdlib.h>
typedef struct _NODE
{
int beg;
int end;
}NODE;
//0,右边融合；1，左边融合；2，中间，不用理会；-1，不相交
int check(NODE i1,NODE i2)
{
if( i2.beg >= i1.beg && i2.beg <= i1.end && i2.end > i1.end )
return 0;
else if( i2.end >= i1.beg && i2.end <= i1.end && i2.beg < i1.beg  )
return 1;
else if( i2.beg >= i1.beg&& i2.end<= i1.end)
return 2;
else
return -1;
}

void quick_sort(NODE *node,int l,int r)
{
if (l < r)
{
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
int i = l, j = r;
NODE x = node[l];
while (i < j)
{
while(i < j && node[j].beg >= x.beg) // 从右向左找第一个小于x的数
j--;
if(i < j)
node[i++] = node[j];

while(i < j && node[i].beg < x.beg) // 从左向右找第一个大于等于x的数
i++;
if(i < j)
node[j--] = node[i];
}
node[i] = x;
quick_sort(node, l, i - 1); // 递归调用
quick_sort(node, i + 1, r);
}
}

int main()
{
int n;
scanf("%d",&n);
int i;
NODE *input = (NODE *)malloc(sizeof(NODE) * n);
int *flag = (int *)malloc(sizeof(int) * n);
for(i=0 ; i< n; i++)
{
//0 未标记 ；1已经融合过； 2加工过
flag[i] = 0;
scanf("%d %d",&input[i].beg,&input[i].end);
}
flag[0] = 2;
int isAdd = 0;
int j=0;
int status;
int cou=1;
while(1)
{
for( i=j+1 ; i< n ; i++)
{
if( flag[i]==0)
{
status = check(input[j],input[i]);
if( status==0)
{
input[j].end= input[i].end;
isAdd = 1;
flag[i]=1;
}
else if( status==1)
{
input[j].beg= input[i].beg;
isAdd = 1;
flag[i]=1;
}
else if(status==2 )
{
flag[i]=1;
}
}
}
//当融合到无法融合的时候，寻找下一个
if( isAdd == 0)
{
for(i=j ; i < n && flag[i]!=0; i++);
//全被标记，结束寻找
if( i==n)
{
break;
}
j = i;
flag[j] = 2;
cou++;
}
isAdd = 0;
}
int max_ji = 0,max_meiji = 0;
NODE *getMax = (NODE *)malloc(sizeof(NODE) * cou);

//筛选出最终的时间组合，并找出最大挤奶时间
for(i=0,j=0 ; i < n; i++)
{
if(flag[i] ==2)
{
getMax[j++] = input[i];
max_ji = (input[i].end-input[i].beg) > max_ji ? (input[i].end-input[i].beg) : max_ji;
}
}

//排序先
quick_sort(getMax,0, cou-1);
//筛选最大不挤奶时间
for(i=0 ; i< cou-1 ; i++)
{
max_meiji = (getMax[i+1].beg- getMax[i].end)>max_meiji ?(getMax[i+1].beg- getMax[i].end):max_meiji;
}

printf("%d %d",max_ji,max_meiji);

return 0;
}

这个是后来根据参考，自己纠正的算法，首先把排序做了。用快排，然后思路就瞬间清晰了。

其实，本训练的目的，就是掌握不同问题的解决思路，在每个问题解决的时候，学会使用其中应当明白的算法。

自然，解法还是有很多的。但是要以题目本身的目的来围绕着学习。

像本类题目的目的，就是写出容易理解的枚举算法。或者通过一定的优化手段，再来枚举。之前一直没想通这个怎么优化。原来就是利用我一直不熟悉的排序算法。

看来之后还要好好补补排序算法了。先把快排弄好吓，快速理解。

#include <stdio.h>
#include <stdlib.h>
typedef struct _NODE
{
int beg;
int end;
}NODE;
void quick_sort(NODE *node,int l,int r)
{
if (l < r)
{
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
int i = l, j = r;
NODE x = node[l];
while (i < j)
{
while(i < j && node[j].beg >= x.beg) // 从右向左找第一个小于x的数
j--;
if(i < j)
node[i++] = node[j];

while(i < j && node[i].beg < x.beg) // 从左向右找第一个大于等于x的数
i++;
if(i < j)
node[j--] = node[i];
}
node[i] = x;
quick_sort(node, l, i - 1); // 递归调用
quick_sort(node, i + 1, r);
}
}

int main()
{
int n;
scanf("%d",&n);
NODE *input = (NODE *)malloc(sizeof(NODE) *n);
int i;
for(i=0 ; i < n; i++)
{
scanf("%d %d",&input[i].beg,&input[i].end);
}
//通过排序的方法，就解决了情况复杂多变的情况。
//本题的核心，就是用排序的方法，简化线段离散化的情况，
//使得问题分析变得简单。
quick_sort(input,0,n-1);

int max_continus=0,max_idle=0;
int max_beg=  input[0].beg,max_end = input[0].end;
for(i=1 ; i< n ; i++)
{
//下一个线段的beg在前一个线段内部，下一个线段将被吸收，取两者最大的end
if( input[i].beg <= max_end)
{
max_end = input[i].end>max_end ? input[i].end:max_end;
}
//反之，将开始另外一段线段的比较。
else
{
max_continus = (max_end-max_beg)>max_continus ? (max_end-max_beg):max_continus;
max_idle = (input[i].beg - max_end)> max_idle ?(input[i].beg - max_end): max_idle;
max_beg = input[i].beg;
max_end = input[i].end;
}
}
//竟然忽略了最后要把结果再次比较一下。嘿哈。浪费了我20分钟。
max_continus = (max_end-max_beg)>max_continus ? (max_end-max_beg):max_continus;
max_idle = (input[i].beg - max_end)> max_idle ?(input[i].beg - max_end): max_idle;
printf("%d %d",max_continus,max_idle);
return 0;
}