NOIP2015提高組復賽Day1Day2詳解

T1:填幻方

這道題目非常水，直接按照題目里說的做就行了

其實機智的你們可以直接跳過題面直接開始做

#include <cstdio>
#include <cstring>
int a[100][100];
int main()
{
    int n;
    memset(a,0,sizeof(a));
    scanf("%d",&n);
    int num=1;
    int i,j;
    i=1; j=n/2+1;
    a[i][j]=1;
    while (num<=n*n)
    {
        num++;
        i--; j++;
        if (i<1 && j<=n)
        {
            i=n;
        }
        else if (i<1 && j>n)
        {
            i++; i++; j--;
        }
        else if (j>n)
        {
            j=1;
        }
        else if (a[i][j]!=0)
        {
            i++;
            j--;
            i++;
        }
        a[i][j]=num;
        /*for (int i=1; i<=n; i++)
        {
            for (int j=1; j<=n; j++)
                printf("%d ",a[i][j]);
            printf("\n");
        }*/
    }
    for (i=1;i<=n; i++)
    {
        for (j=1; j<=n-1; j++)
            printf("%d ",a[i][j]);
        printf("%d\n",a[i][n]);
    }
}

T2:信息傳遞

題目描述

有 n個同學(編號為 1 到 n)正在玩一個信息傳遞的游戲。在游戲里每人都有一個
固定的信息傳遞對象,其中,編號為 i的同學的信息傳遞對象是編號為Ti的同學。 游戲開始時,每人都只知道自己的生日。之后每一輪中,所有人會同時將自己當前
所知的生日信息告訴各自的信息傳遞對象(注意:可能有人可以從若干人那里獲取信息, 但是每人只會把信息告訴一個人,即自己的信息傳遞對象)。當有人從別人口中得知自 己的生日時,游戲結束。請問該游戲一共可以進行幾輪?

輸入

輸入共 2 行。
第 1 行包含 1 個正整數第 1 行包含 1 個正整數 n,表示 n 個人。
第 2 行包含

輸出

輸出共 1 行,包含 1 個整數,表示游戲一共可以進行多少輪。

 

樣例輸入

5 2 4 2 3 1

樣例輸出

3

 

我們根據題目中的意思進行轉化

可以發現每一個點都只有一條出邊

那么我們只需要找圖中的最小環，並且求出它的長度就可以了

我們可以先進行一次拓撲排序，然后圖中剩下的點構成的就是環了

然后我可以進行暴力枚舉

如果一個點的入度不為零，並且它還未被訪問過

那么我們就從這個節點開始暴力求這個環的長度

每找到一個環，我們更新最后的答案A

#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
queue <int> q;
int f[200001]; int flag[200001]; int e[200001];
int main()
{
    memset(flag,0,sizeof(flag));
    int n;
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
    {
        scanf("%d",&f[i]);
        e[f[i]]++;
    }
    for (int i=1; i<=n; i++)
    {
        if (e[i]==0)
        {
            q.push(i);
            flag[i]=1;
        }   
    }
    while (! q.empty())
    {
        int now=q.front();
        q.pop();
        --e[f[now]];
        if (e[f[now]]==0)
        {
            flag[f[now]]=1;
            q.push(f[now]);
        }
    }
    int ans=1000000000;
    for (int i=1; i<=n; i++)
    {
        if (e[i] !=0 && flag[i]==0)
        {
            flag[i]=1;
            int j=f[i];
            int tmp=1;
            while (flag[j]==0)
            {
                flag[j]=1;
                j=f[j];
                tmp++;
            }
            if (tmp<=ans) ans=tmp;
        }
    }
    printf("%d\n",ans);
    return 0;
}

 

T3:斗地主

輸入

第一行包含用空格隔開的2個正整數 T,n ，表示手牌的組數以及每組手牌的張數。

接下來 T 組數據，每組數據 n 行，每行一個非負整數對 ai,bi ，表示一張牌，其中 ai 表示牌的數碼， bi 表示牌的花色，中間用空格隔開。特別的，我們用 1 來表示數碼 A， 11 表示數碼 J， 12 表示數碼 Q， 13 表示數碼 K；黑桃、紅心、梅花、方片分別用 1-4 來表示；小王的表示方法為 0 1 ，大王的表示方法為 0 2 。

輸出

共 T 行,每行一個整數,表示打光第

樣例輸入

1 8

7 4

8 4

9 1

10 4

11 1

5 1

1 4

1 1

樣例輸出

3

 

這道題目看似非常的難

但是我們這里有一個基本的貪心策略

就是我們優先出牌數多的那些出牌順序

因為如果存在一個三順子，你將它拆開來打和合起來打效果其實是一樣的，因為你減少的牌的總量以及類別是相同的

所以我們寧可合起來，也不要分開來打

有了上面這個結論我們就可以輕而易舉地寫出代碼了

我們可以寫個大暴力加最優性剪枝優化

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
#define fo(i,x,y) for(int i=x; i<=y; i++)
#define pr(i,x,y) for(int i=x; i>=y; i--)
#define clear(a,x) memset(a,x,sizeof(a))
#define INF 1e15
#define EPS 1e-8

using namespace std;

int t,N,x,y,a[5],b[14],MaxX;

inline ll read()
{
    int f=1;
    ll Tmp=0;
    char ch=getchar();
    while (ch != '-' && ch < '0' || ch > '9')
    {
        ch=getchar();
    }
    if (ch == '-')
    {
        f=-1;
        ch=getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        Tmp=Tmp * 10 + ch - 48;
        ch=getchar();
    }
    return Tmp * f;
}


int qiu()
{
    int tot=0;
    memset(a,0,sizeof(a));
    for(int i=0;i<=13;i++)
    {
        if (i) a[b[i]]++;
    }
    while(a[4] && a[2]>1) a[4]--,a[2]-=2,tot++;
    while(a[4] && a[1]>1) a[4]--,a[1]-=2,tot++;
    while(a[4] && a[2]) a[4]--,a[2]--,tot++;
    while(a[3] && a[2]) a[3]--,a[2]--,tot++;
    while(a[3] && a[1]) a[3]--,a[1]--,tot++;
    return tot+a[1]+a[2]+a[3]+a[4];
}

void dfs(int u)
{
    if(u>=MaxX) return;int kk=qiu();
    if(u+kk<MaxX) MaxX=u+kk;
    for(int i=2;i<=13;i++)
    {
        int j=i;
        while(b[j]>=3 && j<=13) j++;
        if(j-i>=2)
          for(int v=i+1;v<=j-1;v++)
          {

            for(int vk=i;vk<=v;vk++) b[vk]-=3;
            dfs(u+1);
            for(int vk=i;vk<=v;vk++) b[vk]+=3;
          }
    }
    for(int i=2;i<=13;i++)
    {
        int j=i;
        while(b[j]>=2 && j<=13) j++;
        if(j-i>=3)
          for(int v=i+2;v<=j-1;v++)
          {
            for(int vk=i;vk<=v;vk++) b[vk]-=2;
            dfs(u+1);
            for(int vk=i;vk<=v;vk++) b[vk]+=2;
          }
    }
    for(int i=2;i<=13;i++)
    {
        int j=i;
        while(b[j]>=1 && j<=13) j++;
        if(j-i>=5)
          for(int v=i+4;v<=j-1;v++)
          {
            for(int vk=i;vk<=v;vk++) b[vk]--;
            dfs(u+1);
            for(int vk=i;vk<=v;vk++) b[vk]++;
          }
    }
}

int main()
{
    int _=read();
    N=read();
    while (_--)
    {
        MaxX=2147483647;
        clear(b,0);
        fo(i,1,N)
        {
            int X,Y;
            X=read(); Y=read();
            if (X == 1)
            {

                X=13;
            }
            else
            {
                if (X)
                {
                    X--;
                }
            }
            b[X]++;
        }
        dfs(0);
        printf("%d\n",MaxX);
    }
    return 0;
}

 

 

Day2開始啦

T1:跳石頭

題目描述

一年一度的“跳石頭”比賽又要開始了! 這項比賽將在一條筆直的河道中進行,河道中分布着一些巨大岩石。組委會已經選
擇好了兩塊岩石作為比賽起點和終點。在起點和終點之間,有 N 塊岩石(不含起點和終 點的岩石)。在比賽過程中,選手們將從起點出發,每一步跳向相鄰的岩石,直至到達 終點。
為了提高比賽難度,組委會計划移走一些岩石,使得選手們在比賽過程中的最短跳 躍距離盡可能長。由於預算限制,組委會至多從起點和終點之間移走 M 塊岩石(不能 移走起點和終點的岩石)。

 

輸入

輸入文件第一行包含三個整數 L,N,M,分別表示起點到終點的距離,起點和終 點之間的岩石數,以及組委會至多移走的岩石數。
接下來 N 行,每行一個整數,第 i 行的整數 Di(0 < Di < L)表示第 i 塊岩石與 起點的距離。這些岩石按與起點距離從小到大的順序給出,且不會有兩個岩石出現在同 一個位置。

 

輸出

輸出文件只包含一個整數,即最短跳躍距離的最大值。

 

樣例輸入

25 5 2

2

1 1

1 4

17

21

樣例輸出

4

提示

 

【輸入輸出樣例 1 說明】

將與起點距離為 2 和 14 的兩個岩石移走后,最短的跳躍距離為 4(從與起點距離 17 的岩石跳到距離 21 的岩石,或者從距離 21 的岩石跳到終點)。

【數據規模與約定】

對於 20%的數據,0 ≤ M ≤ N ≤ 10。對於50%的數據,0 ≤ M ≤ N ≤ 100。

對於 100%的數據,0 ≤ M ≤ N ≤ 50,000,1 ≤ L ≤ 1,000,000,000。

 

這道題目我們開始研究這個最終的答案是否具有二分性

如果X可行，那么X+1一定可行

如果X不可行，那么X-1一定不可行

所以我們就可以進行二分答案了

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
int n,k;
int a[500005];
 
bool check(int x)
{
    int tmp=0;int h=0;
    for (int i=1; i<=n; i++)
    {
        if (a[i]-h < x)
        {
            tmp++;
        }
        else h=a[i];
    }
    if (tmp <= k) return true;
    else return false;
}
 
int main()
{
    a[0]=0;
    int L;
    scanf("%d%d%d",&L,&n,&k);
    for (int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    a[++n]=L;
    int l=0,r=1000000000;
    while (l<r)
    {
        //printf("%d %d\n",l,r);
        int mid=(l+r+1)/2;
        if (check(mid)) l=mid;
        else r=mid-1;
    }
    printf("%d",l);
}

T2:子串

題目描述

有兩個僅包含小寫英文字母的字符串 A 和 B。現在要從字符串 A 中取出 k 個互不重疊的非空子串,然后把這 k 個子串按照其在字符串 A 中出現的順序依次連接起來得到一 個新的字符串,請問有多少種方案可以使得這個新串與字符串 B 相等?注意:子串取出 的位置不同也認為是不同的方案。

 

輸入

第一行是三個正整數 n,m,k,分別表示字符串 A 的長度,字符串 B 的長度,以及問題描述中所提到的 k,每兩個整數之間用一個空格隔開。 第二行包含一個長度為 n 的字符串,表示字符串 A。 第三行包含一個長度為 m 的字符串,表示字符串 B。

 

輸出

輸出共一行,包含一個整數,表示所求方案數。由於答案可能很大,所以這里要求輸出答案對 1,000,000,007 取模的結果。

 

樣例輸入

6 3 1

aabaab

aab

6 3 2

aabaab

aab

樣例輸出

2

7

 

這道題目很明顯是一個DP 題

我們可以知道與當前答案有關聯的只有A的第i個字符，B的第j個字符，已經取了k個字符

那么設f[i][j][kk]表示在A串的前i個字符中選kk個子串匹配B串的前j個字符的方案數.求方案數可以采用加法原理，考慮A串的第i個字符,那么這個字符的決策只有取或不取，很明顯，加法原理，把不取的方案數和取的方案數加起來就可以，但是狀態的定義並不能看出這個字符到底取不取，或者說並不能推出結果來，怎么辦呢？

 

那么就用一個數組s[i][j][kk]來表示在A串的前i個字符中選kk個子串匹配B串的前j個字符的方案數，A串的第i個字符會被取到.那么這個s數組該怎么推出來呢？可以發現，如果取第i個字符也有2種可能，因為kk是一定的，第i個字符可能和第i-1個字符合並成一個子串，那么從s[i-1][j][kk]轉移過來，也可能不和第i-1個字符合並成一個子串，那么就要新開一個子串，故kk一定從kk-1轉移過來，根據加法原理，那么s[i][j][kk] = s[i-1][j-1][kk] + f[i-1][j-1][kk-1].

還有一個問題：這是一個三維的狀態轉移方程！空間不一定開的下，再看數據范圍，這絕對MLE,怎么辦?注意到i只能從i或i-1轉移過來，可以想到滾動數組

此處題解參考自某位大佬

 

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

int N,M,K;
int Mod1=1e9 + 7;
char s1[100005];
char s2[100005];
int dp[2][205][205];
int S[2][205][205];

int main()
{
    scanf("%d%d%d",&N,&M,&K);
    scanf("%s",s1+1);
    scanf("%s",s2+1);
    S[0][0][0]=1;
    for (int i=1; i<=N; i++)
    {
        int Now=i & 1;
        int Last=Now ^ 1;
        S[Now][0][0]=1;
        for (int j=1; j<=M; j++)
        {
            for (int k=1; k<=K; k++)
            {
                if (s1[i] == s2[j])
                {
                    dp[Now][j][k]=(dp[Last][j - 1][k] + S[Last][j - 1][k-1]) % Mod1;
                }
                else dp[Now][j][k]=0;
                S[Now][j][k]=(S[Last][j][k] + dp[Now][j][k]) % Mod1;
            }
        }
    }
    printf("%d\n",S[N & 1][M][K]);
    return 0;
}

 

T3：運輸計划

題目描述

公元 2044 年,人類進入了宇宙紀元。
L 國有 n 個星球,還有 n-1 條雙向航道,每條航道建立在兩個星球之間,這 n-1 條
航道連通了 L 國的所有星球。
小 P 掌管一家物流公司,該公司有很多個運輸計划,每個運輸計划形如:有一艘物
流飛船需要從 ui 號星球沿最快的宇航路徑飛行到 vi 號星球去。顯然,飛船駛過一條航道 是需要時間的,對於航道 j,任意飛船駛過它所花費的時間為 tj,並且任意兩艘飛船之 間不會產生任何干擾。
為了鼓勵科技創新,L 國國王同意小 P 的物流公司參與 L 國的航道建設,即允許小 P 把某一條航道改造成蟲洞,飛船駛過蟲洞不消耗時間。
在蟲洞的建設完成前小 P 的物流公司就預接了 m 個運輸計划。在蟲洞建設完成后, 這 m 個運輸計划會同時開始,所有飛船一起出發。當這 m 個運輸計划都完成時,小 P 的 物流公司的階段性工作就完成了。
如果小 P 可以自由選擇將哪一條航道改造成蟲洞,試求出小 P 的物流公司完成階段 性工作所需要的最短時間是多少?

 

輸入

第一行包括兩個正整數 n、m,表示 L 國中星球的數量及小 P 公司預接的運輸計划的

數量,星球從 1 到 n 編號。
接下來 n-1 行描述航道的建設情況,其中第 i 行包含三個整數 ai, bi 和 ti,表示第

i 條雙向航道修建在 ai 與 bi 兩個星球之間,任意飛船駛過它所花費的時間為 ti。 接下來 m 行描述運輸計划的情況,其中第 j 行包含兩個正整數 uj 和 vj,表示第 j 個

運輸計划是從 uj 號星球飛往 vj 號星球。 

 

輸出

共 1 行,包含 1 個整數,表示小 P 的物流公司完成階段性工作所需要的最短時間。 

首先求出每個計划的路徑長度 這里寫的倍增
然后二分答案
對於每個ans 統計＞他的路徑條數 tot 並維護最大差值 dec 
並且對於每條不合法的路徑維護每個點的經過次數
然后枚舉點 如果經過次數==tot說明每一條不合法的都經過他
然后嘗試把它建成蟲洞 如果他對應邊的權值>=dec 那么我們刪掉它ans就合法了
關鍵是統計每個點在非法路徑中的經過次數 ：
維護sum數組 對於每個非法的路徑起點a b LCA(a,b)==s sum[a]++ sum[b]++ sum[s]-=2
這樣網上更新的話 經過的點的sum值都變成1 祖先s的變成0 
這樣就實現了sum數組的維護 

參考自某位大佬

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
bool flag[1000005],flag1[1000005];
int num,n,m;
int fa[300005][30];
long long head[600005],sum[600005],dis[600005],L[600005],R[600005],p[600005],next[600005],father[600005],father1[600005],vet[600005],val[600005];
long long dep[600005],dep1[600005];
 
void add(int u,int v,int cost)
{
    vet[++num]=v;
    val[num]=cost;
    next[num]=head[u];
    head[u]=num;
}
 
void dfs(int u)
{
    flag1[u]=true;
    int len=1;
    while ((1 <<len) <= dep[u])
    {
        fa[u][len]=fa[fa[u][len-1]][len-1];
        ++len;
    }
    int i=head[u];
    while (i != -1)
    {
        if (vet[i] != fa[u][0])
        {
            dep[vet[i]]=dep[u]+1;
            fa[vet[i]][0]=u;
            father[vet[i]]=u;
            father1[vet[i]]=val[i];
            dep1[vet[i]]=dep1[u]+val[i];
            dfs(vet[i]);
        }
        i=next[i];
    }
}
 
int lca(int x,int y)
{
    if (dep[x] < dep[y])
    {
        swap(x,y);
    }
    for (int i=20; i>=0; i--)
    {
        if (dep[x] - dep[y] >= (1 << i))
        {
            x=fa[x][i];
        }
    }
    if (x == y) return x;
    for (int i=20; i>=0; i--)
    {
        if (fa[x][i] != fa[y][i])
        {
            x=fa[x][i];
            y=fa[y][i];
        }
    }
    return fa[x][0];
}
 
void dfs1(int u)
{
    flag[u]=true;
    for (int i=head[u]; i!=-1; i=next[i])
    {
        if (flag[vet[i]] == false)
        {
            dfs1(vet[i]);
            sum[u]=sum[u]+sum[vet[i]];
        }
    }
}
 
bool check(int x)
{
    int ans=0;
    for (int i=1; i<=n; i++)
    {
        sum[i]=0;
    }
    long long maxll=0;
    for (int i=1; i<=m; i++)
    {
        if (dis[i] <= x) continue;
        else
        {
            sum[L[i]]++;
            sum[R[i]]++;
            sum[p[i]]-=2;
            ans++;
            maxll=max(dis[i],maxll);
        }
    }
    dfs1(1);
    long long maxx=0;
    for (int i=1; i<=n; i++)
    {
        if (sum[i] == ans)
        {
            maxx=max(maxx,father1[i]);
        }
    }
    for (int i=1; i<=n; i++)
        flag[i]=false;
    for (int i=1; i<=n; i++)
    {
        sum[i]=0;
    }
    if (maxll - maxx <= x) return true;
    else return false;
}
 
int find(int l,int r)
{
    while (l < r)
    {
        int mid=(l + r) / 2;
        //printf("%d\n",mid);
        if (check(mid)) r=mid;
        else l=mid+1;
    }
    return l;
}
 
int main()
{
    num=0;
    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        head[i]=-1;
    for (int i=1; i<n; i++)
    {
        int u,v,cost;
        scanf("%d%d%d",&u,&v,&cost);
        add(u,v,cost);
        add(v,u,cost);
    }
    memset(flag1,false,sizeof(flag1));
    dep1[1]=0;
    dfs(1);
    int max1=0;
    for (int i=1; i<=m; i++)
    {
        scanf("%d%d",&L[i],&R[i]);
        p[i]=lca(L[i],R[i]);
        dis[i]=dep1[L[i]]+dep1[R[i]]-2*dep1[p[i]];
        max1=max(max1,(int) dis[i]);
    }
    //for (int i=1; i<=m; i++)
    //    printf("%d\n",dis[i]);
    int XXX=find(0,max1);
    printf("%d\n",XXX);
}

 

最后我想說兩句話

Hala Madrid！

李沁么么噠