DP&图论 DAY 2 下午 考试

看一下zhhx的Solution：
? 首先我们设 dp[i][x][y][k] 表示当前到了第 i 层，这一层 x 个，
上一层 y 个，已经有 k 个结束了
? 转移的话就直接枚举一下， y 这一层有 p 个结束了即可，然
后算上结束的代价
? Time complexity O(N5) 到 O(N4 ∗ log(N))
? 我们考虑把第一维优化掉，我们设 dp[x][y][k] 表示最下方一
层 x 个，倒数第二层 y 个，结束了 k 个。
? 转移的时候就直接，枚举 y 这一层结束了 p 个，注意这里代
价不是每一个元素结束的时候记上了，我们在没往下一层
时，我们算一下这一层会产生的贡献。
? Time complexity O(N4)
? 我们再把转移优化掉。
? 我们就考虑每一次是把 y 减 1 表示，把倒数第二层一个元
素封上，还是把 y 个全部分叉转移到 dp[y][x+y][k]，加上这
一层的贡献即可。
? Time complexity O(N3) 滚动数组优化后 Space complexity
O(N2)

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<map>
#include<cassert>
using namespace std;
const int N=755;
typedef unsigned int uint;
const uint inf=(1u<<31)-1;


uint n,a[N],sum[N];

bool cmp(uint x,uint y) {return x>y;}

uint dp[2][N][N];int r;

int main()
{
    
    freopen("A.in","r",stdin);
    freopen("A.out","w",stdout);
    
    
    scanf("%u",&n);
    //assert(3<=n && n<=750);
    
    for (int i=1;i<=n;i++) scanf("%u",&a[i]),assert(1<=a[i] && a[i]<=100000);
    
    sort(a+1,a+n+1,cmp);
    for (int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i];
    
    for (int x=0;x<N;x++)
        for (int y=0;y<N;y++) dp[0][x][y]=dp[1][x][y]=inf;
    
    
    dp[r=0][0][0]=0;
    for (int k=n-1;k>=0;k--) 
    {
        for (int y=n-k;y>=0;y--) 
            for (int x=n-k-y;x>=0;x--) 
            dp[r^1][x][y]=
            min(inf,x==0&&y==0?inf:
                min(
                y==0?inf:dp[r][x][y-1],
                x+y+y+k>n?inf:sum[n]-sum[k] + dp[r^1][y][x+y]
                ) 
            );
        
    /*    for (int x=0;x<=n-(k+1);x++)
            for (int y=0;y<=n-(k+1)-x;y++) dp[r][x][y]=inf;*/
        r^=1;
    }
    
    
    printf("%u\n",sum[n]+dp[r][1][1]);
    return 0;
}

#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;

ll A,B;
int C;
int a[70],na,b[70],nb,p[70];

int mod;
ll f[70][400][400];

ll query(int *a,int i,int sum,int rest,bool o) 
{
    if (sum<0) return 0;
    if (i==0) return sum==0&&rest==0 ? 1:0;
     
    if (!o&&f[i][sum][rest]!=-1) return f[i][sum][rest];
    ll ans=0;
    int up=o ? a[i] : C-1;
     
    for (int j=0;j<=up;j++) 
    ans+=query(a,i-1,sum-j,(rest+mod-j*p[i]%mod)%mod,o&&j==up);
    if (!o) f[i][sum][rest]=ans;
    return ans;
}

int main()
{
    freopen("B.in","r",stdin);
    freopen("B.out","w",stdout);
    scanf("%lld%lld%lld",&B,&A,&C);
    
    B--;
    
    while (A) a[++na]=A%C,A/=C;
    while (B) b[++nb]=B%C,B/=C;
     
     //printf("na=%d\n",na);
    memset(f,-1,sizeof(f));
    
    ll ans=0;
    for (int i=1;i<=na*C;i++)
    {
        mod=i;
        p[1]=1;
        for (int j=2;j<=na;j++) p[j]=p[j-1]*C%mod;
         
        ans+=query(a,na,mod,0,true)-(nb==0 ? 0:query(b,nb,mod,0,true));
         
        for (int x=0;x<=na;x++)
            for (int y=0;y<=i;y++) 
                for (int z=0;z<=mod;z++) f[x][y][z]=-1;
    }
    printf("%lld",ans);
    return 0;
}

#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
using namespace std;
const int N=6006;
typedef long long ll;
const ll inf=5e13;

int n,m,k,len_n,r;

ll len[N],ans,dp[2][N];
struct aa
{
    int L,R;
}t1[N],t2[N];
bool cmp(aa a,aa b) 
{
    if (a.R==b.R) return a.L>b.L;
    return a.R<b.R;
}

int q[N],H,T;


int main()
{
    
    
    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);
    scanf("%d%d",&n,&k);
    for (int i=1;i<=n;i++) scanf("%d%d",&t1[i].L,&t1[i].R),len[i]=t1[i].R-t1[i].L;
    
    sort(len+1,len+n+1);
    for (int i=0;i<k-1;i++) ans+=len[n-i];
    
    sort(t1+1,t1+n+1,cmp);
    
//    printf("ans=%lld\n",ans);
    
    memset(len,0,sizeof(len));
    int mx=0;
    for (int i=1;i<=n;i++)
    if (t1[i].L>mx)
    {
        t2[++m]=t1[i];
        mx=t1[i].L;
    }else len[++len_n]=t1[i].R-t1[i].L;
    
    sort(len+1,len+len_n+1,greater<ll>());
    for (int i=2;i<=n;i++) len[i]+=len[i-1];
    
    sort(t2+1,t2+m+1,cmp);
    
    r=1;
    
    for (int i=1;i<=m;i++) 
    if (t2[1].R<=t2[i].L) dp[0][i]=-inf;else dp[0][i]=t2[1].R-t2[i].L;
    
    ans=max(ans,dp[0][m]+len[k-1]);
    
    for (int j=2;j<=min(k,m);j++,r^=1) 
    {
        q[H=T=1]=1;dp[r][1]=-inf;
        for (int i=2;i<=m;i++)
        {
            while (H<=T&&t2[q[H]+1].R<=t2[i].L) H++;
            if (H<=T) dp[r][i]=dp[r^1][q[H]]+t2[q[H]+1].R-t2[i].L;else dp[r][i]=-inf;
            while (H<=T&&dp[r^1][i]+t2[i+1].R>=dp[r^1][q[T]]+t2[q[T]+1].R)  T--;
            q[++T]=i;
        }
        ans=max(ans,dp[r][m]+len[k-j]);
    }
    
    printf("%lld\n",ans);
    return 0;
}