【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;
}