HDU2073（暴力） VS HDU5214（贪心）

题意：给出n组l[i],r[i]，求出能够相互嵌套的最大个数；

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

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

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

2073代码：

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <cstdlib>
 6 #define repu(i,a,b) for(int i=a;i<b;i++)
 7 #define N 1100
 8 #define MOD 4294967296
 9 #define ll long long
10 using namespace std;
11 int vis[N];
12 struct S
13 {
14     int l,r;
15     bool operator < (const S& p) const
16     {
17         if(r == p.r)
18             return l < p.l;
19         return r < p.r;
20     }
21 } m[N];
22 int main()
23 {
24     int T,n,a,b,c,d;
25     while(cin>>n&&n)
26     {
27         repu(i,0,n)
28         cin>>m[i].l>>m[i].r;
29         sort(m,m+n);
30         memset(vis,0,sizeof(vis));
31         int maxn = 0;
32         int u = m[0].r,v= m[0].l;
33 //        repu(i,0,n)
34 //        cout<<m[i].l<<" "<<m[i].r<<endl;
35         repu(i,0,n)
36         {
37             repu(j,i+1,n)
38             {
39                 if(u <= m[j].l && v < m[j].l)
40                 {
41                     u = m[j].r;
42                     v = m[j].l;
43                     vis[i]++;
44                 }
45             }
46             vis[i]++;
47             // cout<<vis[i]<<endl;
48             maxn = max(vis[i],maxn);
49         }
50         cout<<maxn<<endl;
51     }
52     return 0;
53 }

5214代码：

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<algorithm>
 4 #include<cmath>
 5 #define MOD 4294967296
 6
 7 using namespace std;
 8 typedef unsigned int LL;
 9 int T;
10 int n;
11 const int N=10000005;
12 LL s1,e1;
13 LL L1,R1,L2,R2;
14 LL minL,minR,maxL,maxR;
15 LL a,b,c,d;
16 LL l[N],r[N];
17 int main()
18 {
19     scanf("%d",&T);
20     while(T--)
21     {
22         cin>>n>>s1>>e1>>a>>b>>c>>d;
23         l[1]=s1;
24         r[1]=e1;
25         minL=maxL=l[1];
26         minR=maxR=r[1];
27         for(int i=2; i<=n; i++)
28         {
29             l[i]=l[i-1]*a+b;
30             r[i]=r[i-1]*c+d;
31             if(l[i]>r[i])
32                 swap(l[i],r[i]);
33             if(r[i]<minR)///找出最大最小的两组，到时候直接跟这两组比较就好了
34             {
35                 minL=l[i];
36                 minR=r[i];
37             }
38             if(l[i]>maxL)
39             {
40                 maxL=l[i];
41                 maxR=r[i];
42             }
43         }
44         bool flag=false;
45         for(int i=1; i<=n; i++)
46         {
47             if(l[i]>minR&&r[i]<maxL)
48             {
49                 flag=true;
50                 break;
51             }
52         }
53         printf("%s\n",flag?"YES":"NO");
54     }
55     return 0;
56 }