【NOIP2017】Day5

Solution

T1：
我们发现对于区间[l,r]只能有两个棋子，所以记f[i][j][k]为放到i步，最近的为j，第二近的为k，方案数。

$$f[i+1][j][k]+=f[i][j][k]$$ $$f[i+1][i+1][j]+=f[i][j][k]([k,i+1]不在一个限制内部)$$ 我们可以O(N^3)预处理出来[i,j]是否在一个限制内，在O(N^3)DP。
T2：
我们发现走法只可能是起点、终点、药水之间走，所以可以与处理出来这些点之间的距离再状压DP即可，这个状压不是很难
T3：
这是到思维题，有点难。
注意题目给出的条件：若x已知，则x的父亲也已知，这很重要（考试时没注意）
首先我们可以知道若一个节点有两个白儿子，则不可能确定，我们可以跳过
我们从小到大考虑权值（这是一步贪心，也是解题的关键），假如这个权值没有出现过，我们就把它压入栈中作为 限制权值，如果遇到某个已知的变量我们判断限制权值数量是否恰好等于子树中节点数， 注意，这里的子树只算白节点（也就是未确定的儿子为根的子树），假如是的话就可以确定这一个根白节点就是限制权值中的最大值，否则我们就无法确定，只能说这里有这些限制权值中的一部分，我们设限制权值数位num_xz，子树大小为size[u]，这样我们可以得到 自由元的数量num_zy=num_xz-size[u]即有这么多的数即可以在这里又可以在别的地方。
到这里我们讲到了最重要的两个概念 限制权值和 自由元，我们判断一棵子树是否满足以下条件：1.只有一个儿子不确定 2.num_zy+num_xz=size[u] 3.num_xz>0.

对于这两个数左边的可以确定，右边的却不行，为什么？当我们做左边的树时到6时num_zy=1，到10 num_zy=1,num_xz=3,1+3=4，当我们做右边的数树到9做完num_zy=4,接着就是10了，这两个例子大致可以说明 限制权值和 自由元的区别了，限制权值表示只能在当前子树，而且从大到小，自由元则不确定，所以必须有限制权值我们才能确定根的权值，然后递归处理，每次判断完要减去size[u]。

CODE

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
#define MOD 1000000007
const int MAXN=305;
int f[MAXN][MAXN][MAXN],l[MAXN],r[MAXN],n,m,ans=0;
bool b[MAXN][MAXN];

int main()
{
    freopen("chess.in","r",stdin);
    freopen("chess.out","w",stdout);
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
        scanf("%d%d",&l[i],&r[i]);
    for (int i=1;i<=n;i++)
        for (int j=i;j<=n;j++)  
            for (int k=1;k<=m && !b[i][j];k++)
                if (l[k]<=i && j<=r[k]) b[i][j]=b[j][i]=true;
    f[0][0][0]=1;
    for (int i=0;i<=n;i++)
        for (int j=0;j<=i;j++)
            for (int k=0;k<=j;k++)
            {
                if (k==j && k!=0) continue;
                f[i+1][j][k]+=f[i][j][k];
                if (f[i+1][j][k]>=MOD) f[i][j][k]-=MOD;
                if (!b[k][i+1])
                {
                    f[i+1][i+1][j]+=f[i][j][k];
                    if (f[i+1][i+1][j]>=MOD) f[i+1][i+1][j]-=MOD;
                }
            }
    for (int i=0;i<=n;i++)
        for (int j=0;j<=i;j++)
            ans=(ans+f[n][i][j])%MOD;
    printf("%d\n",ans);
    return 0;
}

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int MAXN=4000,MAXM=20000;
int Head[MAXN],dis[MAXN];
int a[1005][1005],d[20][20],dp[20][1<<15];
bool vis[MAXN];
int n,m,k,sx,sy,tx,ty,tot=0,ans;


//#define id(x,y,z) (((x-1)*m+(y))*2+z)
#define power(a) ((a)*(a))
int id(int x,int y)
{
    return (x-1)*m+y;
}
struct Edge{
    int v,w,next;
    friend bool operator < (const Edge &x,const Edge &y)
    {
        return x.w>y.w;
    }
}edge[MAXM];
priority_queue<Edge>Q;
struct node{
    int id,val;
}b[20];
void add_edge(int x,int y,int z)
{
    edge[++tot]=(Edge){y,z,Head[x]};
    Head[x]=tot;    
}
void Dijkstra(int s)
{
    memset(dis,0x3f,sizeof(dis));
    memset(vis,false,sizeof(vis));
    dis[s]=0; Q.push((Edge){s,0,0});
    while (!Q.empty())
    {
        int u=Q.top().v;
        Q.pop();
        if (vis[u]) continue;
        vis[u]=true;
        for (int i=Head[u];i;i=edge[i].next)
        {
            int v=edge[i].v,w=edge[i].w;
            if (dis[u]+w<dis[v])
                dis[v]=dis[u]+w,Q.push((Edge){v,dis[v],0});     
        }
    }
}
void prepare()
{
    scanf("%d%d%d%d%d%d%d",&n,&m,&k,&sx,&sy,&tx,&ty);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m;j++)
        {
            scanf("%d",&a[i][j]);   
            if (i>1) add_edge(id(i-1,j),id(i,j),power(a[i][j]-a[i-1][j]));
            if (i>1) add_edge(id(i,j),id(i-1,j),power(a[i][j]-a[i-1][j]));
            if (j>1) add_edge(id(i,j-1),id(i,j),power(a[i][j]-a[i][j-1]));
            if (j>1) add_edge(id(i,j),id(i,j-1),power(a[i][j]-a[i][j-1]));
        }
    for (int i=1;i<=k;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);   
        b[i]=(node){id(x,y),z};
    }
    b[0]=(node){id(sx,sy),0}; b[k+1]=(node){id(tx,ty),0};
    for (int i=0;i<=k+1;i++)
    {
        Dijkstra(b[i].id);
        for (int j=0;j<=k+1;j++)
        {
            if (i==j) continue;
            d[i][j]=dis[b[j].id];           
        }       
    }
}
inline void relax(int &x,int y){x=min(x,y);}
int main()
{
    freopen("escape.in","r",stdin);
    freopen("escape.out","w",stdout);
    prepare();
    memset(dp,0x3f,sizeof(dp));
    for (int i=1;i<=k;i++)
        dp[i][1<<i-1]=d[0][i]-b[i].val;
    ans=d[0][k+1];
    for (int i=1;i<1<<k;i++)
        for (int j=1;j<=k;j++)
            if (i & (1<<j-1))
            {
                for (int l=1;l<=k;l++)
                    if (!(i & (1<<l-1)))
                        relax(dp[l][i | (1<<l-1)],dp[j][i]+d[j][l]-b[l].val);
                ans=min(ans,dp[j][i]+d[j][k+1]);
            }
    printf("%d\n",ans); 
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
    int v[1100000];
int random(int a,int b)
{
    return rand()%(b-a+1)+a;
}
int main()
{
    srand(time(0));
    freopen("tree.in","w",stdout);
    int n=1000000,t=n;

    v[1]=t;
    cout<<n<<endl;
    printf("%d %d\n",1,t);
    for (int i=2;i<=n;i++)
    {
        int x=random(1,i-1);
        int y=random(0,4);
        if (!v[x]) y=0;
        else y=1;
        v[i]=y*(--t);
        printf("%d %d\n",x,v[i]);


    }



    return 0;
}