HDU2073（暴力） VS HDU5214（贪心）

题意：给出n组l[i],r[i]，求出能够相互连接的最大个数，比如(1,2) ,(2,3),(5,6)就是可以连接的3组数据；

思路：2073数组大小为100，纯暴力就可以了，不过注意排序时，按照r的顺序从小到大；

5214数组大小为10000000，纯暴力的话绝对超时，但是要求能找到3组的时候就输出YES即可，因此从两边贪心就好了，本来以为排序更方便一些，不过TLE了，改成找最大最小就好了；

误区：我以为的是图论，求最长路径（bellman-ford可以求最长路，只要吧权值改成相反数即可），其实适用于2073，不过大材小用了，而且判的很严格，容易MLE，TLE；

2073代码：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cstdlib>
 #define repu(i,a,b) for(int i=a;i<b;i++)
 #define N 1100
 #define MOD 4294967296
 #define ll long long
 using namespace std;
 int vis[N];
 struct S
 {
     int l,r;
     bool operator < (const S& p) const
     {
         if(r == p.r)
             return l < p.l;
         return r < p.r;
     }
 } m[N];
 int main()
 {
     int T,n,a,b,c,d;
     while(cin>>n&&n)
     {
         repu(i,,n)
         cin>>m[i].l>>m[i].r;
         sort(m,m+n);
         memset(vis,,sizeof(vis));
         int maxn = ;
         int u = m[].r,v= m[].l;
 //        repu(i,0,n)
 //        cout<<m[i].l<<" "<<m[i].r<<endl;
         repu(i,,n)
         {
             repu(j,i+,n)
             {
                 if(u <= m[j].l && v < m[j].l)
                 {
                     u = m[j].r;
                     v = m[j].l;
                     vis[i]++;
                 }
             }
             vis[i]++;
             // cout<<vis[i]<<endl;
             maxn = max(vis[i],maxn);
         }
         cout<<maxn<<endl;
     }
     return ;
 }

5214代码：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #define MOD 4294967296

 using namespace std;
 typedef unsigned int LL;
 int T;
 int n;
 const int N=;
 LL s1,e1;
 LL L1,R1,L2,R2;
 LL minL,minR,maxL,maxR;
 LL a,b,c,d;
 LL l[N],r[N];
 int main()
 {
     scanf("%d",&T);
     while(T--)
     {
         cin>>n>>s1>>e1>>a>>b>>c>>d;
         l[]=s1;
         r[]=e1;
         minL=maxL=l[];
         minR=maxR=r[];
         for(int i=; i<=n; i++)
         {
             l[i]=l[i-]*a+b;
             r[i]=r[i-]*c+d;
             if(l[i]>r[i])
                 swap(l[i],r[i]);
             if(r[i]<minR)///找出最大最小的两组，到时候直接跟这两组比较就好了
             {
                 minL=l[i];
                 minR=r[i];
             }
             if(l[i]>maxL)
             {
                 maxL=l[i];
                 maxR=r[i];
             }
         }
         bool flag=false;
         for(int i=; i<=n; i++)
         {
             if(l[i]>minR&&r[i]<maxL)
             {
                 flag=true;
                 break;
             }
         }
         printf("%s\n",flag?"YES":"NO");
     }
     return ;
 }