NOIP模拟测试18（T3待更新）

T1：

　　直接模拟，详见代码注释。

　　复杂度$O(NM)$。

Code：

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
const int N=;
const int M=;
int n,m,tot=;
int a[N][N];
int u[M],d[M],l[M],r[M],bl[M];//上下左右边界及水箱编号
vector<int> v[M],bx[N],by[N];//v做临接表，bx和by存储水箱边界
int get()
{
    char c=getchar();
    while(c!='.'&&c!='-'&&c!='|'&&c!='+'&&(c<''||c>''))
        c=getchar();
    if(c>=''&&c<='') return c-'';//水箱编号
    else if(c=='-') return -;//横向管道
    else if(c=='|') return -;//纵向管道
    else if(c=='+') return -;//管道转折，其实和前两个一样，可以不做区分
    else return -;//空格子
}
void find(int id,int x,int y)//二分查找水箱边界
{
    int xx,yy;
    yy=lower_bound(bx[x].begin(),bx[x].end(),y)-bx[x].begin();
    r[id]=bx[x][yy];l[id]=bx[x][yy-];
    xx=lower_bound(by[y].begin(),by[y].end(),x)-by[y].begin();
    d[id]=by[y][xx];u[id]=by[y][xx-];
}
void clean(int id)//将整个水箱的区域都标上该水箱的编号
{
    for(int i=u[id];i<=d[id];i++){
        for(int j=l[id];j<=r[id];j++)
            a[i][j]=id;
    }
}
int walk(int x,int y)//沿管道寻找
{
    a[x][y]=-;
    if(a[x+][y]>) return a[x+][y];//水箱成树形
    if(a[x+][y]<=-&&a[x+][y]>=-) return walk(x+,y);
    if(a[x][y+]<=-&&a[x][y+]>=-) return walk(x,y+);
    if(a[x][y-]<=-&&a[x][y-]>=-) return walk(x,y-);
}
void work(int id)
{
    for(int i=d[id];i>=u[id];i--){//水必定先进入靠下的水箱，所以从下到上枚举
        if(a[i][l[id]-]<=-&&a[i][l[id]-]>=-)
            v[id].push_back(walk(i,l[id]-));
        if(a[i][r[id]+]<=-&&a[i][r[id]+]>=-)
            v[id].push_back(walk(i,r[id]+));
    }
}
void print(int id)//按水箱高度递归输出
{
    for(int i=;i<v[id].size();i++)
        print(v[id][i]);
    printf("%d\n",id);
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            a[i][j]=get();//获取格子类型
            if(a[i][j]>=&&a[i][j-]>=){//注意水箱编号大于一位的情况
                a[i][j]+=*a[i][j-];//用类似快读的思想
                a[i][j-]=-;//每个水箱内只能有一个数字
            }
            if(a[i][j]>=-&&a[i][j]<=-){//将水箱边界存入
                bx[i].push_back(j);
                by[j].push_back(i);
            }
        }
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            if(a[i][j]>=){
                bl[++tot]=a[i][j];//记录水箱编号，水箱编号可能不连续
                find(a[i][j],i,j);//寻找水箱边界
            }
        }
    }
    for(int i=;i<=tot;i++) clean(bl[i]);
    for(int i=;i<=tot;i++) work(bl[i]);
    print();
    return ;
}

T1

T2：

　　DP好题，不过暴力也能A。

　　题目大意：一条线上N个点，共有精灵M个，时间为一时位于K，精灵都有价值，但一段时间后会消失，求收获的最大权值。

　　DP（正解）：

　　

　　搜索（暴力）：

　　

　　暴力压正解，我就不说什么了…………

　　下面说DP：搜索可以自己想

　　　　设DP数组f[i][j][k]，表示i～j已经走过，目前位于i的最大值。

　　　　由于抓取精灵不需要时间，而且权值均为正，所以每次遇到精灵一定会抓。

　　　　先对精灵按照坐标排序。

　　　　将精灵的坐标连同起始点离散，初始化为负无穷，时间为一时起点处权值赋为0。

　　　　这是一个区间DP，先枚举时间，然后枚举区间长度，再枚举左端点，算出右端点。

　　　　然后我们就可以开心地DP了：

　　　　　　i为时间，L为左端点，R为右端点，val代表精灵的权值，p代表精灵的位置，t为精灵消失的时间。

　　　　　　f[L-1][R][i+1]=max(f[L-1][R][i+1],f[L][R][i]+val[L-1])　 (i+p[L]-p[L-1]<=t[L-1])

　　　　　　f[L-1][R][i+1]=max(f[L-1][R][i+1],f[L][R][i])　　　　　　(i+p[L]-p[L-1]>t[L-1])

　　　　　　f[R+1][L][i+1]=max(f[R+1][L][i+1],f[R][L][i]+val[R+1])　 (i+p[R+1]-p[R]<=t[R+1])

　　　　　　f[R+1][L][i+1]=max(f[R+1][L][i+1],f[R][L][i])　　　　　　(i+p[R+1]-p[R]>t[R+1])

　　　　　　f[R+1][L][i+1]=max(f[R+1][L][i+1],f[L][R][i]+val[R+1])　 (i+p[R+1]-p[L]<=t[R+1])

　　　　　　f[R+1][L][i+1]=max(f[R+1][L][i+1],f[L][R][i])　　　　　　(i+p[R+1]-p[L]>t[R+1])

　　　　　　f[L-1][R][i+1]=max(f[L-1][R][i+1],f[R][L][i]+val[L-1])　 (i+p[R]-p[L-1]<=t[L-1])

　　　　　　f[L-1][R][i+1]=max(f[L-1][R][i+1],f[R][L][i])　　　　　　(i+p[R]-p[L-1]>t[L-1])

　　　　后四行的转移方程代表从区间的一头走到另一头再扩展区间，不能丢。

　　　　起点算作一只贡献为0的精灵，方便判断。

　　　　注意判断在该时间内精灵是否已消失。

　　　　DP过程中不断对ans取max，最后的max即为答案。

　　　　共有M只精灵，时间的最大值为T。

　　　　时间复杂度$O(M^2T)$

Code:

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int N=;
 const int M=;
 const int inf=;
 int n,k,m,t=,ans=;
 int s[M],dp[M][M][N];
 struct point {
     int a,b,c;
 }p[M];
 bool comp(const point a1,const point a2)
 {
     return a1.a<a2.a;
 }
 int main()
 {
     scanf("%d%d%d",&n,&k,&m);
     for(int i=;i<=m;i++){
         scanf("%d%d%d",&p[i].a,&p[i].b,&p[i].c);
         t=max(p[i].c,t);
     }
     p[++m].a=k;
     sort(p+,p+m+,comp);
     for(int i=;i<=t;i++){
         for(int j=;j<=m;j++){
             for(int l=;l<=m-j+;l++){
                 int r=l+j-;
                 dp[l][r][i]=dp[r][l][i]=-inf;
             }
         }
     }
     for(int i=;i<=m;i++){
         s[i]=p[i].a;p[i].a=i;
         if(s[i]==k)
             dp[i][i][]=p[i].b;
     }
     for(int i=;i<=t;i++){
         for(int j=;j<=m;j++){
             for(int l=;l<=m-j+;l++){
                 int r=l+j-;
                 if(dp[l][r][i]>=){
                     if(l>=){
                         int ti=i+s[l]-s[l-];
                         if(ti<=p[l-].c)
                             dp[l-][r][ti]=max(dp[l-][r][ti],dp[l][r][i]+p[l-].b);
                         else
                             dp[l-][r][ti]=max(dp[l-][r][ti],dp[l][r][i]);
                         ans=max(ans,dp[l-][r][ti]);
                     }
                     if(r<=m-){
                         int ti=i+s[r+]-s[l];
                         if(ti<=p[r+].c)
                             dp[r+][l][ti]=max(dp[r+][l][ti],dp[l][r][i]+p[r+].b);
                         else
                             dp[r+][l][ti]=max(dp[r+][l][ti],dp[l][r][i]);
                         ans=max(ans,dp[r+][l][ti]);
                     }
                 }
                 if(dp[r][l][i]>=){
                     if(l>=){
                         int ti=i+s[r]-s[l-];
                         if(ti<=p[l-].c)
                             dp[l-][r][ti]=max(dp[l-][r][ti],dp[r][l][i]+p[l-].b);
                         else
                             dp[l-][r][ti]=max(dp[l-][r][ti],dp[r][l][i]);
                         ans=max(ans,dp[l-][r][ti]);
                     }
                     if(r<=m-){
                         int ti=i+s[r+]-s[r];
                         if(ti<=p[r+].c)
                             dp[r+][l][ti]=max(dp[r+][l][ti],dp[r][l][i]+p[r+].b);
                         else
                             dp[r+][l][ti]=max(dp[r+][l][ti],dp[r][l][i]);
                         ans=max(ans,dp[r+][l][ti]);
                     }
                 }
             }
         }
     }
     printf("%d\n",ans);
     return ;
 }

T2

建议搜索AC的人打一遍DP，毕竟正经NOIP数据是不会这么水的。