【洛谷 p5464】缩小社交圈_p5464 缩小社交圈-优快云博客

本文链接：https://blog.youkuaiyun.com/MrTinTin/article/details/102673431

该博客主要介绍了如何解决洛谷平台上的P5464问题，通过动态规划和树状数组优化的方法，实现了求解社交圈缩小问题的算法。文章详细讲解了代码实现，包括dp状态转移和树状数组的前缀和维护技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

https://www.luogu.org/problem/P5464

dp（60分）

f[i][j]表示当前选第i个上一个选的是第j个

//luogu 5464 60分算法
#include<iostream>
#include<algorithm>
#define ll long long
#define f(i,l,r) for(i=(l);i<=(r);i++)
using namespace std;
const int MAXN=2005,MOD=1e9+7;
int n;
struct Node{
    int x,y;
    bool operator < (const Node& tmp)const{
        return y<tmp.y;
    }
}a[MAXN];
ll dp[MAXN][MAXN];
ll ans;
int main()
{
    int i,j,k;
    cin>>n;
    f(i,1,n){
        cin>>a[i].x>>a[i].y;
    }
    sort(a+1,a+1+n);
    f(i,1,n){
        dp[i][0]=1;
        ans++;
        f(j,1,i-1){
            if(a[j].y<a[i].x) continue;
            if(a[j].x<a[i].x){
                f(k,0,j-1){
                    if(a[k].y>=a[i].x) continue;
                    dp[i][j]+=dp[j][k];
                    dp[i][j]%=MOD;
                }
            }
            else{
                f(k,0,j-1){
                    if(a[k].y>=a[j].x) continue;
                    dp[i][j]+=dp[i][k];
                    dp[i][j]%=MOD;
                }
            }
            ans=(ans+dp[i][j])%MOD;
        }
    }
    cout<<ans%MOD<<endl;
    return 0;
}

树桩数组优化（100）

//luogu 5464 60分算法
#include<iostream>
#include<algorithm>
#define ll long long
#define f(i,l,r) for(i=(l);i<=(r);i++)
using namespace std;
const int MAXN=2005,MOD=1e9+7;
int n;
struct Node{
    int x,y;
    bool operator < (const Node& tmp)const{
        return y<tmp.y;
    }
}a[MAXN];
int li[MAXN<<1];
ll dp[MAXN][MAXN];
ll ans;
ll tree[MAXN][MAXN<<1];
int max_num;
void add(int pos,int x,ll d)
{
    int i;
    for(i=x;i<=max_num;i+=(i&(-i))){
        tree[pos][i]+=d;
    }
    return;
}
ll query(int pos,int x)
{
    int i;
    ll res=0;
    for(i=x;i;i-=(i&(-i))){
        res+=tree[pos][i];
        res%=MOD;
    }
    return res;
}
int main()
{
    int i,j,k;
    cin>>n;
    f(i,1,n){
        cin>>a[i].x>>a[i].y;
        li[i+i-1]=a[i].x;
        li[i+i]=a[i].y;
    }
    li[n+n+1]=0;
    sort(li+1,li+1+n+n+1);
    max_num=unique(li+1,li+1+n+n+1)-li-1;
    f(i,1,n){
        a[i].x=lower_bound(li+1,li+1+max_num,a[i].x)-li;
        a[i].y=lower_bound(li+1,li+1+max_num,a[i].y)-li;
    }
    sort(a+1,a+1+n);
    f(i,1,n){
     //  dp[i][0]=1;
        add(i,1,1);
        ans++;
        f(j,1,i-1){
            if(a[j].y<a[i].x) continue;
            if(a[j].x<a[i].x){
       //         f(k,0,j-1){
       //             if(a[k].y>=a[i].x) continue;
         //           dp[i][j]+=dp[j][k];
           //         dp[i][j]%=MOD;
             //   }
                dp[i][j]+=query(j,a[i].x-1);
                dp[i][j]%=MOD;
                add(i,a[j].y,dp[i][j]);
            }
            else{
        //        f(k,0,j-1){
        //            if(a[k].y>=a[j].x) continue;
        //            dp[i][j]+=dp[i][k];
        //            dp[i][j]%=MOD;
        //        }
                dp[i][j]+=query(i,a[j].x-1);
                dp[i][j]%=MOD;
                add(i,a[j].y,dp[i][j]);
            }
            ans=(ans+dp[i][j])%MOD;
        }
    }
    cout<<ans%MOD<<endl;
    return 0;
}

优化：由于对右端点排了序，所以每次在树状数组上的更新操作的位置单调递增。因此考虑直接前缀和维护，每次查询前维护即可。

//luogu 5464 60分算法
#include<iostream>
#include<algorithm>
#define ll long long
#define f(i,l,r) for(i=(l);i<=(r);i++)
using namespace std;
const int MAXN=2005,MOD=1e9+7;
int n;
struct Node{
    int x,y;
    bool operator < (const Node& tmp)const{
        return y<tmp.y;
    }
}a[MAXN];
int li[MAXN<<1];
ll dp[MAXN][MAXN];
ll ans;
ll sum[MAXN][MAXN<<1];
int pos[MAXN];
int main()
{
    int i,j,k;
    cin>>n;
    f(i,1,n){
        cin>>a[i].x>>a[i].y;
        li[i+i-1]=a[i].x;
        li[i+i]=a[i].y;
    }
    sort(li+1,li+1+n+n);
    int len=unique(li+1,li+1+n+n)-li-1;
    f(i,1,n){
        a[i].x=lower_bound(li+1,li+1+len,a[i].x)-li;
        a[i].y=lower_bound(li+1,li+1+len,a[i].y)-li;
    }
    sort(a+1,a+1+n);
    f(i,1,n){
        dp[i][0]=sum[i][0]=1;
        ans++;
        f(j,1,i-1){
            if(a[j].y<a[i].x) continue;
            if(a[j].x<a[i].x){
       //         f(k,0,j-1){
       //             if(a[k].y>=a[i].x) continue;
         //           dp[i][j]+=dp[j][k];
           //         dp[i][j]%=MOD;
             //   }
                f(k,pos[j]+1,a[i].x-1){
                    sum[j][k]+=sum[j][k-1];
                    sum[j][k]%=MOD;
                }
                pos[j]=max(pos[j],a[i].x-1);
                dp[i][j]+=sum[j][a[i].x-1];
                dp[i][j]%=MOD;
                sum[i][a[j].y]+=dp[i][j];
                sum[i][a[j].y]%=MOD;
            }
            else{
        //        f(k,0,j-1){
        //            if(a[k].y>=a[j].x) continue;
        //            dp[i][j]+=dp[i][k];
        //            dp[i][j]%=MOD;
        //        }
                f(k,pos[i]+1,a[j].x-1){
                    sum[i][k]+=sum[i][k-1];
                    sum[i][k]%=MOD;
                }
                pos[i]=max(pos[i],a[j].x-1);
                dp[i][j]+=sum[i][a[j].x-1];
                dp[i][j]%=MOD;
                sum[i][a[j].y]+=dp[i][j];
                sum[i][a[j].y]%=MOD;
            }
            ans=(ans+dp[i][j])%MOD;
        }
    }
    cout<<ans%MOD<<endl;
    return 0;
}