DP:Wooden Sticks(POJ 1065)

　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　摆木棍

　　题目大意：即使有一堆木棍，给一个特殊机器加工，木棍都有两个属性，一个是l一个是w，当机器启动的时候（加工第一根木棒的时候），需要一分钟，在这以后，设机器加工的上一根木棒的长度是l，质量是w，下一次加工的木棒长度为l`,质量为w`，当且仅当l`>=l且w`>=w时，机器不需要额外的时间，否则还需要一分钟重新启动，问你最短的加工时间？

　　下面介绍两个方法：

　　方法一，直接贪心法：

　　这个方法的原理是：因为我们总是想把更多的木棍按序排列，所以我们可以先把一个属性先排列了，再考虑另一个属性，那么这样的话假设我们先排序l，那么的话我们就只用看w就可以了，但是在我第一次想的时候我犯了一个很严重的错误，那就是我把w也按照升序来操作了（而没有跟新当前最大质量），实际上我们还要更新stick的最大质量，这样才能行（当然要used域了）

　　还要注意的是排序的时候当l相等的时候，w记得按照升序排

　　代码太简单了，我不贴了，反正这算法跑挺慢的，我写的跑47ms，没啥意思，我们来点有意思的方法。

　　方法二：LIS（最长下降子序列）

　　在扯这个方法之前，我们先来讲一下组合数学的东西：偏序集和Dilworth定理

　　偏序集的定义：

　　设一个集合P，里面满足关系R，设xRy表示x与y满足R相关，x!Ry表示x与y不相关

　　1.如果对于X中的所有元素x,都有x与x满足R的关系，那么则说明R是自反的

　　2.如果对于X中的所有元素x,都不满足R的关系（x!Rx），那么说明R是反自反的。

　　3.如果对于X所有的x和y，都有xRy,x!Ry，则说明R是反对称的，否则如果xRy和xRy成立时，x!=y则说明R是对称的

　　4.如果X所有元素xyz,满足xRy,yRz，如果一定存在xRz，则说明R是传递的

　　偏序集就是一个自反，反对称且传递的关系，偏序是一种关系（比如集合的包含，大于小于都是偏序，特别的，一切不带等号的偏序都是严格偏序）

　　现在我们直接用偏序集的定理（不证），详细证明方法看维基百科https://en.wikipedia.org/wiki/Dilworth%27s_theorem

　　

　　偏序集的定理1：

　　令（X,≤）是一个有限偏序集，并令r是其最大链的大小。则X可以被划分成r个但不能再少的反链。

　　偏序集的定理2：（DilWorth定理）

　　令（X,≤）是一个有限偏序集，并令m是反链的最大的大小。则X可以被划分成m个但不能再少的链。

　　也就是链的最小化划分数=反链的最大长度

　　参考http://blog.csdn.net/xuzengqiang/article/details/7266034

　　

　　那么说到这里，你就明白了，这一题其实就是最著名的LIS（只不过他是要求反链）

　　LIS有两个解法，各有优劣，第一个解法虽然是O（n^2），但是可以显示出所有的链长和回溯显示链

　　第一个解法其实就是DP，我们从头到尾搜索数组，不断更新当前位置的最长长度（当然这个要满足下降关系），然后找出最长的链就可以了，很简单

　　

 #include <iostream>
 #include <functional>
 #include <algorithm>

 using namespace std;
 typedef struct woods_
 {
     int length;
     int weight;

 }WOODS;
 typedef int Position;
 int fcomp(const void *a, const void *b)
 {
     if ((*(WOODS *)a).length != (*(WOODS *)b).length)
         return (*(WOODS *)a).length - (*(WOODS *)b).length;
     else
         return (*(WOODS *)a).weight - (*(WOODS *)b).weight;
 }

 static WOODS woods_set[];
 static int dp[];

 void Search(const int);

 int main(void)
 {
     int case_sum, woods_sum;
     scanf("%d", &case_sum);
     for (int i = ; i < case_sum; i++)
     {
         scanf("%d", &woods_sum);
         for (int j = ; j < woods_sum; j++)
             scanf("%d%d", &woods_set[j].length, &woods_set[j].weight);

         qsort(woods_set, woods_sum, sizeof(WOODS), fcomp);
         memset(dp, , sizeof(dp));
         if (woods_sum == )
             printf("0\n");
         else Search(woods_sum);
     }
     return ;
 }

 void Search(const int woods_sum)
 {
     int ans = ;

     dp[] = ;
     for (int i = ; i < woods_sum; i++)
     {
         dp[i] = ;
         for (int j = ; j < i; j++)
         {
             if (woods_set[j].weight > woods_set[i].weight)
                 dp[i] = max(dp[j] + , dp[i]);
         }
     }
     ans = ;
     for (int i = ; i < woods_sum; i++)
         ans = max(ans, dp[i]);
     printf("%d\n", ans);
 }

　　第二个方法是O(nlogn)，这个很快，原理就是我们的最长连储存就可以了，然后用二分的方法更新元素，并且用贪婪的方法，不断更新stacks里面的元素（比如我们按照从大到小排，那么不断更新最大就可以了），让链的增长潜能变大！这个方法的缺点就是不能显示链（显示的也是错的），而且只能找最长的那一条。

　　不过为什么这个算法能成立也是很有趣的，因为我们一直在更新元素，但是最后的链的序不一定就是原来的序，其实内在的原因就是这个方法把每一个元素都等价了，其实不管我们怎么找，如果我们只用找最长的话，那么其实我们只用把潜力变大？（下降链找最大元素，上升链找最小元素），那么这样的链的长度最后一定是最大的

　　代码：

　　

 #include <iostream>
 #include <functional>
 #include <algorithm>

 using namespace std;
 typedef struct woods_
 {
     int length;
     int weight;

 }WOODS;
 typedef int Position;
 int fcomp(const void *a, const void *b)
 {
     if ((*(WOODS *)a).length != (*(WOODS *)b).length)
         return (*(WOODS *)a).length - (*(WOODS *)b).length;
     else
         return (*(WOODS *)a).weight - (*(WOODS *)b).weight;
 }

 static WOODS woods_set[];
 static int stacks[];

 void Search(const int);
 Position Binary_Search(const int,int,int,const int len);

 int main(void)
 {
     int case_sum, woods_sum;
     scanf("%d", &case_sum);
     for (int i = ; i < case_sum; i++)
     {
         scanf("%d", &woods_sum);
         for (int j = ; j < woods_sum; j++)
             scanf("%d%d", &woods_set[j].length, &woods_set[j].weight);

         qsort(woods_set, woods_sum, sizeof(WOODS), fcomp);
         //memset(stacks, -1, sizeof(stacks));
         if (woods_sum == )
             printf("0\n");
         else Search(woods_sum);
     }
     return ;
 } 

 Position Binary_Search(const int goal, int left, int right, const int len)
 {
     int mid;

     while (left <= right && left != len)//二分法维护序列
     {
         mid = (left + right) / ;
         if (goal < stacks[mid])
             left = mid + ;
         else
             right = mid - ;
     }
     return left;
 }

 void Search(const int woods_sum)
 {
     int pos, len = ;

     stacks[] = -;
     for (int i = ; i < woods_sum; ++i)
     {
         pos = Binary_Search(woods_set[i].weight, , len, len);

         stacks[pos] = woods_set[i].weight;
         if (pos == len)
             len++;
     }
     printf("%d\n", len);
 }