Atcoder Educational DP Contest

最新推荐文章于 2023-10-27 22:48:41 发布
最新推荐文章于 2023-10-27 22:48:41 发布
阅读量206 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/shanxieng/p/10232228.html
版权

前面简单一点的题直接过吧。

A 暴力DP

B 怎么还是暴力DP

C 还是暴力DP

D 直接背包

E 这个背包不太一样了，这里有一个技巧，就是因为价值很小，所以直接对价值背包，求出来达到某一个权值最小的重量，然后找到满足限制的最大的价值即可。注意，如果能达到权值比这个还大的点，那么这个点很显然也是可以达到的。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=210000;
const int inf=0x3f3f3f3f;

int n,w,tot;
ll f[Maxn],v;

signed main() {
//  freopen("test.in","r",stdin);
    read(n,tot);
    memset(f,0x3f,sizeof(f));f[0]=0;
    int now=0;
    for(int i=1;i<=n;i++) {
        read(w,v);
        for(int j=now+v;j>=v;j--) f[j]=min(f[j],f[j-v]+w);
        now+=v;
    }
    for(int i=now;i>=0;i--) f[i]=min(f[i],f[i+1]);
    int ans=0;
    while(f[ans]<=tot) ans++;
    printf("%d\n",ans-1);
    return 0;
}

F 套路题，统计答案略恶心，还是贴一下代码吧。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=3100;
const int inf=0x3f3f3f3f;

int f[Maxn][Maxn],pre[Maxn][Maxn],top;
char a[Maxn],s[Maxn],st[Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    scanf("%s%s",a,s);
    int n=strlen(a),m=strlen(s);
    for(int i=0;i<m;i++) if(a[0]==s[i]) f[0][i]=1;
    for(int i=0;i<m;i++) pre[0][i]=-1;
    for(int i=1;i<n;i++) {
        int now=0,las=-1;
        for(int j=0;j<m;j++) {
            if(a[i]==s[j]) {
                if(f[i-1][j]>now+1) {
                    now=f[i-1][j],las=(a[i-1]==s[j]?i-1:pre[i-1][j]);
                    pre[i][j]=las;
                    f[i][j]=now;
                }
                else {
                    pre[i][j]=las;
                    f[i][j]=now+1;
                    if(f[i-1][j]>now)
                        now=f[i-1][j],las=(a[i-1]==s[j]?i-1:pre[i-1][j]);
                }
            }
            else {
                if(f[i-1][j]>now)
                    now=f[i-1][j],las=(a[i-1]==s[j]?i-1:pre[i-1][j]);
                pre[i][j]=las;
                f[i][j]=now;
            }
        }
    }
    int ans=0,temp;
    for(int i=0;i<m;i++) if(f[n-1][i]>ans) {
        ans=f[n-1][i];
        temp=i;
    }
    if(ans==0) return 0;
    int nx,ny=temp;
    if(a[n-1]==s[temp]) nx=n-1;
    else nx=pre[n-1][temp];
    while(nx!=-1) {
        st[++top]=a[nx];
        nx=pre[nx][ny];
        int ans=0,temp;
        for(int i=0;i<ny;i++)
            if(f[nx][i]>ans) ans=f[nx][i],temp=i;
        ny=temp;
    }
    while(top) putchar(st[top--]);
    return 0;
}

G 直接DAG上的DP，太简单了不放代码了。

H 每个点都是从上边或左边转移即可。

I 概率DP，直接记有i个正面朝上的概率，然后就可以\(O(n^2)\)DP了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=11000;
const int inf=0x3f3f3f3f;
const int mod=1000000007;

int n;
double f[Maxn],p;

signed main() {
//  freopen("test.in","r",stdin);
    read(n);
    f[0]=1;
    for(int i=1;i<=n;i++) {
        scanf("%lf",&p);
        for(int j=i;j>=1;j--) f[j]=(f[j]*(1.0-p)+f[j-1]*p);
        f[0]*=1.0-p;
    }
    double ans=0;
    for(int i=n/2+1;i<=n;i++) ans+=f[i];
    printf("%.10lf",ans);
    return 0;
}

J 期望DP，因为每个数都很小，直接记目前剩一个，两个，三个的分别有多少。好像从小到大转移要方便一些。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=310;
const int inf=0x3f3f3f3f;
const int mod=1000000007;

int n,x,a[4];
double f[Maxn][Maxn][Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    read(n);
    for(int i=1;i<=n;i++) {
        read(x);
        a[x]++;
    }
    for(int i=0;i<=n;i++)
        for(int j=0;j<=n-i;j++)
            for(int k=0;k<=n-i-j;k++) {
                if(!i&&!j&&!k) continue;
                double x=i+j+k,p=(double)n/x;
                if(i) f[i][j][k]+=f[i-1][j+1][k]*i/x;
                if(j) f[i][j][k]+=f[i][j-1][k+1]*j/x;
                if(k) f[i][j][k]+=f[i][j][k-1]*k/x;
                f[i][j][k]+=p;
            }
    printf("%.10lf",f[a[3]][a[2]][a[1]]);
    return 0;
}

K 记忆化搜索，如果你知道博弈论，那就很简单了。

L 这个总觉得在哪里见过，不过结论也很简单，就直接记左右端点DP，长度由小到大枚举即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=3100;
const int inf=0x3f3f3f3f;
const int mod=1000000007;

int n;
ll f[Maxn][Maxn],a[Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    read(n);
    for(int i=1;i<=n;i++) read(a[i]);
    for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++) {//[j-i+1,j]
            int l=j-i+1,r=j,len=n-i;
            f[l][r]=max(a[l]-f[l+1][r],a[r]-f[l][r-1]);
        }
    printf("%lld",f[1][n]);
    return 0;
}

M 首先\(O(nk^2)\)的DP很简单，然后用前缀和优化一下就好了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=110000;
const int inf=0x3f3f3f3f;
const int mod=1000000007;

int n,k,x;
ll f[Maxn],g[Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    read(n,k);
    f[0]=1;
    for(int i=1;i<=n;i++) {
        read(x);
        int sum=0;
        for(int j=0;j<=x;j++) {
            sum+=f[j];
            sum%=mod;
            g[j]=sum;
        }
        for(int l=0,r=x+1;r<=k;l++,r++) {
            sum+=f[r]-f[l];
            sum%=mod;
            sum+=mod;
            sum%=mod;
            g[r]=sum;
        }
        memcpy(f,g,sizeof(f));
    }
    printf("%d",f[k]);
    return 0;
}

N 合并石子不解释。

O 枚举前i个men，匹配了哪i个women的方案数，注意i是没必要记的。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=3100000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

int n,a[30][30],f[Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    read(n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            read(a[i][j]);
    int end=1<<n;f[0]=1;
    for(int i=1;i<end;i++) {
        int cnt=0;
        for(int j=1,nh=1;j<=n;j++,nh<<=1)
            if(i&nh) cnt++;
        for(int j=1,nh=1;j<=n;j++,nh<<=1)
            if((i&nh)&&a[cnt][j]) f[i]=(f[i]+f[i^nh])%mod;
    }
    printf("%d\n",f[end-1]);
    return 0;
}

P 很简单的入门树形DP。

Q 首先\(O(n^2)\)的DP很简单，然后用数据结构优化即可。

R 首先\(O(kn^2)\)的DP很简单，然后用矩乘优化即可。

S 简单的数位DP，具体还是看代码吧。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define qmax(x,y) (x=max(x,y));
using namespace std;

typedef long long ll;
const int Maxn=11000;
const ll mod=1000000007;

char a[Maxn];
int k,f[Maxn][110],ans;

int main() {
    scanf("%s",a);
    scanf("%d",&k);
    int n=strlen(a);
    f[0][0]=1;
    for(int i=1;i<n;i++)
        for(int l=0;l<=9;l++)
        for(int j=0;j<=k;j++) f[i][(j+l)%k]=(f[i][(j+l)%k]+f[i-1][j])%mod;
    int sum=0;
    for(int i=0;i<n;sum=(sum+a[i]-'0')%k,i++)
        for(int j=0;j<a[i]-'0';j++) {
            ans+=f[n-i-1][(k-(sum+j)%k)%k];
            ans%=mod;
        }
    if(sum==0) ans++;ans--;ans+=mod;
    ans%=mod;
    printf("%d",ans);
    return 0;
}

T 记fij为前i个数其中第i个数排名为j的方案数，然后用前缀和和后缀和维护即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=31000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

int f[Maxn],pre[Maxn],suf[Maxn],n;

char readch() {
    char ch=gc();
    while(ch!='>'&&ch!='<') ch=gc();
    return ch;
}

signed main() {
//  freopen("test.in","r",stdin);
    read(n);f[1]=pre[1]=suf[1]=1;
    for(int i=2;i<=n;i++) {
        if(readch()=='<') for(int j=1;j<=i;j++) f[j]=pre[j-1];
        else for(int j=1;j<=i;j++) f[j]=suf[j];
        for(int j=1;j<=i;j++) pre[j]=(pre[j-1]+f[j])%mod;
        for(int j=i;j>=1;j--) suf[j]=(suf[j+1]+f[j])%mod;
    }
    printf("%d",pre[n]);
    return 0;
}

U 常见的枚举子集的套路，转移的系数要预处理一下，然后就是\(O(3^n)\)。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define qmax(x,y) (x=max(x,y));
using namespace std;

typedef long long ll;
const int Maxn=110000;
const ll mod=1000000007;

int n,a[21][21];
ll f[Maxn],g[Maxn];

int main() {
    scanf("%d",&n);int end=1<<n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++) scanf("%d",&a[i][j]);
    for(int i=0;i<end;i++)
        for(int j=1,tempp=1;j<=n;j++,tempp<<=1)
            if(i&tempp)
                for(int k=j,tempt=tempp;k<=n;k++,tempt<<=1)
                    if(i&tempt) f[i]+=a[j][k];
    for(int i=0;i<end;i++) g[i]=f[i];
    for(int i=0;i<end;i++)
        for(int s=i&(i-1);s;s=i&(s-1)) qmax(g[i],g[i^s]+f[s]);
    printf("%lld",g[end-1]); 
    return 0;
}

V 换根DP，具体请参考代码。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define qmax(x,y) (x=max(x,y));
using namespace std;

typedef long long ll;
const int Maxn=210000;
const ll mod=1000000007;

int to[Maxn],nxt[Maxn],first[Maxn],tot=1;
ll f[Maxn],g[Maxn],pr[Maxn],su[Maxn],p[Maxn],ans[Maxn],m;
int n,u,v;

inline void add(int u,int v) {
    to[tot]=v;
    nxt[tot]=first[u];
    first[u]=tot++;
    to[tot]=u;
    nxt[tot]=first[v];
    first[v]=tot++;
}

void dfs(int root,int fa) {
    int tot=0;
    f[root]++;
    for(int i=first[root];i;i=nxt[i])
        if(to[i]!=fa) {
            dfs(to[i],root);
            f[root]=f[root]*f[to[i]]%m;
        }
    for(int i=first[root];i;i=nxt[i]) if(to[i]!=fa) p[++tot]=to[i];
    f[root]++;f[root]%=m;
    pr[0]=su[tot+1]=1;
    for(int i=1;i<=tot;i++) pr[i]=pr[i-1]*f[p[i]]%m;
    for(int i=tot;i>=1;i--) su[i]=su[i+1]*f[p[i]]%m;
    for(int i=1;i<=tot;i++) g[p[i]]=pr[i-1]*su[i+1]%m;
}

void dfs2(int root,int fa) {
    if(root==1) ans[root]=1;
    else ans[root]=(g[root]*ans[fa]+1)%m;
    for(int i=first[root];i;i=nxt[i])
        if(to[i]!=fa) dfs2(to[i],root);
}

int main() {
    scanf("%d%lld",&n,&m);
    for(int i=1;i<n;i++) {
        scanf("%d%d",&u,&v);
        add(u,v);
    }
    dfs(1,1);
    dfs2(1,1);
    for(int i=1;i<=n;i++) printf("%lld\n",ans[i]*(m+f[i]-1)%m);
    return 0;
}

W 首先把所有的区间按照右端点排序，然后从1到n依次考虑，设fi为在第i个位置为1的最大值，那么我们每次令这个值为前面所有值的最大值，然后把扫过的区间加在这些值上，这个就可以用线段树做了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=3100000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

int tl[Maxn],tr[Maxn],n,m;
ll tn[Maxn],flag[Maxn];

void build(int root,int l,int r) {
    tl[root]=l;tr[root]=r;
    int mid=l+r>>1;
    if(l==r) return;
    build(root<<1,l,mid);
    build((root<<1)|1,mid+1,r);
}

inline void update(int root) {
    tn[root]=max(tn[root<<1],tn[(root<<1)|1]);
}

void pushdown(int root) {
    if(flag[root]) {
        flag[root<<1]+=flag[root];
        tn[root<<1]+=flag[root];
        flag[(root<<1)|1]+=flag[root];
        tn[(root<<1)|1]+=flag[root];
        flag[root]=0;
    }
}

ll query(int root,int x) {
    int l=tl[root],r=tr[root],mid=l+r>>1;
    if(r==x) return tn[root];
    pushdown(root);
    if(x<=mid) return query(root<<1,x);
    else return max(tn[root<<1],query((root<<1)|1,x));
}

void change(int root,int l,int r,ll x) {
    int lc=tl[root],rc=tr[root],mid=lc+rc>>1;
    if(l<=lc&&r>=rc) {
        flag[root]+=x;
        tn[root]+=x;
        return;
    }
    pushdown(root);
    if(l<=mid) change(root<<1,l,r,x);
    if(r>mid) change((root<<1)|1,l,r,x);
    update(root);
}

struct node {
    int l,r;
    ll x;
}b[Maxn];

int cmp(node a,node b) {
    return a.r<b.r;
}

signed main() {
//  freopen("test.in","r",stdin);
    read(n,m);
    for(int i=1;i<=m;i++)
        read(b[i].l,b[i].r,b[i].x);
    sort(b+1,b+m+1,cmp);
    build(1,1,n);
    int zhy=1,nh=1;
    for(int i=1;i<=n;i++) {
        change(1,i,i,query(1,i));
        while(b[nh].r==i) {
            change(1,b[nh].l,b[nh].r,b[nh].x);
            nh++;
        }
    }
    printf("%lld",max(tn[1],0ll));
    return 0;
}

X 神仙の结论：按照w+s排序然后背包即可。

至于为什么是对的，可以感性理解一下。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=31000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

struct node {
    int w,s;
    ll v;
}a[Maxn];

int n;
ll f[Maxn],ans;

int cmp(node a,node b) {
    return a.w+a.s<b.w+b.s;
}

signed main() {
//  freopen("test.in","r",stdin);
    read(n);
    for(int i=1;i<=n;i++)
        read(a[i].w,a[i].s,a[i].v);
    sort(a+1,a+n+1,cmp);
    for(int i=1;i<=n;i++)
        for(int j=a[i].s;j>=0;j--)
            qmax(f[j+a[i].w],f[j]+a[i].v);
    for(int i=0;i<Maxn;i++) qmax(ans,f[i]);
    printf("%lld\n",ans);
    return 0;
}

Y 这个跟前面的类似，可以用容斥算答案，但是暴力容斥是\(O(n^3)\)的，很显然通过不了本题。

但是我们可以注意到把这些点排序后，这个转移的时候是在一个DAG上转移的，那么我们在这个DAG上直接转移，时间复杂度即可降为\(O(n^2)\)。从点i到点j的方案数为\(C_{|x_i-x_j|+|y_i-y_j|}^{|x_i-x_j|}\)

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=210000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

ll jc[Maxn],ijc[Maxn],inv[Maxn],n,m,q,f[Maxn];

struct node {
    ll x,y;
}a[Maxn];

ll C(int n,int k) {
    return jc[n]*ijc[k]%mod*ijc[n-k]%mod;
}

int cmp(node a,node b) {
    return a.x==b.x?a.y<b.y:a.x<b.x;
}

signed main() {
//  freopen("test.in","r",stdin);
    read(n,m);
    inv[0]=inv[1]=1;
    for(int i=2;i<=n+m;i++) inv[i]=(mod-mod/i)*inv[mod%i]%mod;
    jc[0]=ijc[0]=1;
    for(int i=1;i<=n+m;i++) jc[i]=jc[i-1]*i%mod,ijc[i]=ijc[i-1]*inv[i]%mod;
    read(q);
    for(int i=1;i<=q;i++) read(a[i].x,a[i].y);
    sort(a+1,a+q+1,cmp);
    a[0]=(node){1,1};a[++q]=(node){n,m};
    f[0]=1;
    for(int i=0;i<q;i++) for(int j=i+1;j<=q;j++) if(a[i].y<=a[j].y)
        f[j]=(mod+f[j]-f[i]*C(a[j].x-a[i].x+a[j].y-a[i].y,a[j].x-a[i].x)%mod)%mod;
    printf("%lld",(mod-f[q])%mod);
    return 0;
}

Z 蒟蒻表示不会斜率优化，于是学了一晚上。

所以这道题就很裸了啊，直接斜率优化就好了，如果不会的话可以百度一下。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cctype>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
using namespace std;

inline char gc() {
//  static char buf[100000],*p1,*p2;
//  return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
    return getchar();
}

template<class T>
int read(T &ans) {
    ans=0;char ch=gc();T f=1;
    while(!isdigit(ch)) {
        if(ch==EOF) return -1;
        if(ch=='-') f=-1;
        ch=gc();
    }
    while(isdigit(ch))
        ans=ans*10+ch-'0',ch=gc();
    ans*=f;return 1;
}

template<class T1,class T2>
int read(T1 &a,T2 &b) {
    return read(a)!=EOF&&read(b)!=EOF?2:EOF;
}

template<class T1,class T2,class T3>
int read(T1 &a,T2 &b,T3 &c) {
    return read(a,b)!=EOF&&read(c)!=EOF?3:EOF;
}

typedef long long ll;
const int Maxn=310000;
const int inf=0x3f3f3f3f;
const ll mod=1000000007;

int n;
ll C,h[Maxn],f[Maxn];

struct node {
    ll x,y;
}a[Maxn];

signed main() {
//  freopen("test.in","r",stdin);
    read(n,C);
    for(int i=1;i<=n;i++) read(h[i]);
    int zhy=1,nh=0;
    a[++nh]=(node){-2*h[1],h[1]*h[1]};
    for(int i=2;i<=n;i++) {
        while(zhy!=nh&&h[i]*a[zhy+1].x+a[zhy+1].y<h[i]*a[zhy].x+a[zhy].y) zhy++;
        f[i]=a[zhy].x*h[i]+a[zhy].y+C+h[i]*h[i];
        ll x=-2*h[i],y=f[i]+h[i]*h[i];
        while(zhy!=nh&&1.0*(y-a[nh].y)*(a[nh].x-a[nh-1].x)>1.0*(a[nh].y-a[nh-1].y)*(x-a[nh].x)) nh--;
        a[++nh]=(node){-2*h[i],f[i]+h[i]*h[i]};
    }
    printf("%lld",f[n]);
    return 0;
}

转载于:https://www.cnblogs.com/shanxieng/p/10232228.html

weixin_33862188
关注
Atcoder Educational DP Contest 题解 + 总结
Hacheylight
01-07 5624
待补
AtCoder Educational DP Contest 题解
Demilly123的博客
04-14 936
AtCoder Educational DP Contest 题解
Atcoder Educational DP Contest 题解
weixin_30900589的博客
09-25 684
A - Frog 1/B - Frog 2 入门... 1 #include<cstdio> 2 #define abs(a) ((a)>=0?(a):(-(a))) 3 #define min(a,b) ((a)<(b)?(a):(b)) 4 #define maxn 100050 5 using namespace std; ...
【刷题记录】[AtCoder Educational DP Contest] 经典dp类型及方法题解合集
03-31 1923
温故而知新，不为师至少不是孙子
狂补dp Atcoder Educational DP Contest(全)
hao_6_6的博客
08-25 2229
狂补dp Atcoder Educational DP Contest(全) 注意 为了减少篇幅，本博客代码部分只放主代码部分，其余省略快读、快输、头文件等代码，即把代码看做伪代码更佳 A - Frog 1 幼儿级别的dp，直接dp便可 void problem() { int n = IO(); for (int i = 0; i < n; ++i) num[i] = IO(); for (int i = 1; i < n; ++i) { dp[i]
Atcoder DP Contest M题解
FelFa_1414666的博客
04-07 914
atcoder 题目传送门，经典的 dp + 前缀和优化。 更好的阅读体验。 题意 有 nnn 个不同的小朋友和 kkk 个相同的糖，给每个小朋友分配若干个糖且糖要分配完，每个小朋友分配糖的上限个数为 aia_iai​，求分配方案总数。 1≤n≤1001\le n\le 1001≤n≤100 1≤k≤1051\le k\le 10^51≤k≤105 1≤ai≤k1\le a_i\le k1≤ai​≤k 思路 朴素的 dp 状态：dp(i,j)dp(i,j)dp(i,j) 表示考虑到第
atcoder dp contest 经典 dp 题选做
FuDuoDuo_qwq的博客
10-27 130
可以将 dp 的第二维放在线段树上转移，那么就做完了。经典 dp 的时候将区间限制挂在。首先很容易想到暴力 dp。点的区间限制的权值和。
Atcoder DP Contest J题解
FelFa_1414666的博客
04-07 189
这是一道很好的期望 dp 题。atcoder 题目传送门 更好的阅读体验。 题意 有 nnn 个盘子，每个盘子有 aia_iai​ 个寿司，每次等概率选择一个盘子吃掉其中一个寿司，选到空盘子不变化，求吃完所有寿司的期望步数。 1≤n≤3001\le n\le 3001≤n≤300 1≤ai≤31\le a_i\le 31≤ai​≤3 分析 有同学可能没有做过期望 dp ，这道题能很好地诠释所谓 “期望步数” 的意义，加深你的理解。所谓期望值是概率与其对应答案值的积的总和。 有了这个公式我们可
Atcoder DP Contest T题解
FelFa_1414666的博客
04-07 539
一道需要一定分析的 dp 题目。 atcoder 题目传送门 & 洛谷题目传送门 更好的阅读体验 Description 给定 nnn 和一个长度为 n−1n-1n−1 的字符串（由 ‘<’ 和 ‘>’ 组成），求数列 1,2,...,n1,2,...,n1,2,...,n 有多少种排列，使得相邻数之间的大小关系与字符串中大于号小于号相符合，答案对 109+710^9+7109+7 取模。 1≤n≤30001\le n\le 30001≤n≤3000 Solution1 anal
[ATCoder] dp contest 题解
William_Wang_的博客
02-07 748
对于某一步的决策 , 会受到上一步决策选了哪些物品 , 用了多少容量的影响。概率 dp , 某一状态受之前状态影响 , 也会受到当前选第。DAG 上的动态规划 : 受到已经访问的点和上一步走到的点影响。范围的状态转移而来 , 因此需要枚举到。, 后者已知 , 因此正序枚举。天选择活动影响 , 因此设计。的贡献也应该做到最小花费即。的范围很大 , 但考虑到。与 D 不同 , 此题。可以采用记忆化搜索的方式。, 因此优先正序枚举。, 即满足最优子结构。收益占据的最少的空间。期望 dp , 考虑。
Atcoder DP Contest V题解（换根dp）
FelFa_1414666的博客
04-08 252
这是树形 dp 中的换根 dp。 atcoder 题目传送门 & 洛谷题目传送门 Description 有一个 nnn 个节点的树，对一些节点染色，使得所有被染色的节点是一个连通块。求对于 1,2,...,n1,2,...,n1,2,...,n 每个节点，该节点被染色的方案个数。所有答案对 MMM 取模。 1≤n≤1051\le n\le 10^51≤n≤105 2≤M≤1092\le M\le 10^92≤M≤109 Solution 换根 dp，我们需要考虑两个 dp 状态：
Atcoder Yahoo Programming Contest 2019 F Pass DP
TYB的博客
02-13 305
Solution 观察最后的序列，对于1≤i≤n1\le i\le n1≤i≤n，前iii个球只会由前iii个人传来，而后nnn个球则没有限制。有了这个，直接简单DP，fi,jf_{i,j}fi,j​表示前iii个球，用了jjj个蓝球的方案数，最后乘个组合数就好了。 Code #include&lt;bits/stdc++.h&gt; using namespace std; #define LL...
【Atcoder K - Stones】dp
我是谁 --- 卡比兽
04-23 829
Atc K 意思是有 n 个石块 每个石块有 a[i]个东西 然后你初始体积是 K 从First 先选 谁不能从当前的块里继续选 谁就输了 输出赢的人 我们知道 设dp[k][t]代表当前有k个石头 t代表人 true则赢 false则输 那么dp[k][t] |= !dp[k-arr[i]][!t] 因为如果另一个人 k-arr[i] 必输 那么你只要取 arr[i] 让他达到这个状态 你就必赢...
atcoder D - AtCoder Express 2(DP + 思维)
林鸿清的blog
08-18 604
https://abc106.contest.atcoder.jp/tasks/abc106_d 真是个牛批的题 题意； 给一个长度n 编号 1-n 的数组， m个操作， 每次操作选定 [L,R] 搞一次， q个查询，每次查询问[L,R] 严格子区间内，搞了几回 。例如: 操作 [1,1] [2,2] [1,2] , [1,6] 查询[1 2] 得到3 思路： 一开始前缀...
Educational DP Contest / DP まとめコンテスト部分题解
fyc的博客
01-07 1745
前言： dp太差，开个大坑 因为太多题了，只做现场AC小于300的题
atcoder dp专题 T - Permutation
the best 的博客
11-26 710
题意： 长度为n的全排列，给出长度为n-1字符串，只包含“<”和“>”,问有多少种排列方式，使得排列的数字大小满足给出的字符串。 题解： dp[i][j]表示前i个数字为1-i的全排列并且第i个数字是j且满足大小关系的方案数，再设sum[i][j]。表示第i个位置放1~j的方案数之和，即前缀和，那么状态转移便是： if(s[i]=='>') { dp[i+1][j]=(dp[i+1][j]+sum[i][i+1]-sum[i][j-1]+mod)%mod; } else {
AtCoder Beginner Contest 050 C - Lining Up
Fighting_Eagle的博客
02-14 213
C - Lining Up 题目大意： 有n个人 编号是从1到n，他们不知道自己所在的位置，但是他们知道自己左边和右边的人数之差的绝对值，根据所给的数据，问有多少种可能？ 分析： 首先这个题要根据n的奇偶性来讨论 当n为偶数时： 给出的数据一定是奇数，因为左边和右边人的个数一定是一奇一偶 之差肯定是奇数 当n为奇数时: 给出的数据一定是偶数，因为左边和右边人的个数一定是两奇或者两偶 之差肯定是偶数...
atcoder dp专题(updating)
qq_43412251的博客
02-02 802
atcoder dp专题 E 是一个背包问题的变式，因为其背包容量达到了1e9，所以常规的一维数组无法存下，而每个物品的价值很小，所以我们将一维数组的下标定义为物品的价值。从寻找一定空间的最大价值，变式为一定价值所需的最小空间。 for(int i=1;i<=n;i++) for(int j=MAXN-1;j>=c[i];j--) { dp[j]=min(dp[j],dp[j-c[i]]+w[i]); if(dp[j]<=m)
atcoder beginner contest 265
最新发布
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值