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,0,n)
        cin>>m[i].l>>m[i].r;
        sort(m,m+n);
        memset(vis,0,sizeof(vis));
        int maxn = 0;
        int u = m[0].r,v= m[0].l;
//        repu(i,0,n)
//        cout<<m[i].l<<" "<<m[i].r<<endl;
        repu(i,0,n)
        {
            repu(j,i+1,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 0;
}

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=10000005;
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[1]=s1;
        r[1]=e1;
        minL=maxL=l[1];
        minR=maxR=r[1];
        for(int i=2; i<=n; i++)
        {
            l[i]=l[i-1]*a+b;
            r[i]=r[i-1]*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=1; i<=n; i++)
        {
            if(l[i]>minR&&r[i]<maxL)
            {
                flag=true;
                break;
            }
        }
        printf("%s
",flag?"YES":"NO");
    }
    return 0;
}