2019 Wannafly summer camp Day1

赛后补题：

　　A：（https://codeforces.com/contest/449/problem/B）

　　最短路+思维

　　对不起，我不会写Dijkstra

　　不知道从什么时候开始，我的Dij一直是这样的：

　　

struct cmp{
    bool operator()(int a,int b){
        return dis[a]>dis[b];
    }
};
priority_queue<int,vector<int>,cmp>pq;

　　正确写法：

　

struct cmp {
    bool operator()(pil a, pil b) {
        return a.second > b.second;
    };
};

priority_queue<pil, vector<pil >, cmp> pq;

很明显这是错的。。。hhhhh

原因在于：这个堆因为dis[u]会变化，所以这个堆根本就是个假的堆！

从另一个角度来讲:

队列中维护的是入队时候的dis而不是时时变化的dis，dis会随着更新而变化

还有一个地方:

 void dij() {
        fill(dis, dis + maxn, 1e18);
        priority_queue<pil, vector<pil >, cmp> pq;
        pq.push({1, 0});
        dis[1] = 0;
        while (!pq.empty()) {
            int now = pq.top().first;
            pq.pop();
            if (vis[now]) continue;                              //一定要有入队标记，否则重复入队会T到飞起
            vis[now] = 1;
            for (int i = 0; i < G[now].size(); ++i) {
                int to = G[now][i].first,
                        v = G[now][i].second;
 
                if (!vis[to] && dis[to] > dis[now] + v) {        //这里更新的时候也要看是否已经入队
                    ind[to] = 1;
                    dis[to] = dis[now] + v;
                    pq.push({to, dis[to]});
                } //else if (dis[to] == dis[now] + v) ++ind[to]; //这是根据本题题意来的。
            }
        }
    }

　综上所述：我不会写dij，，，，hhhhh（天知道我之前的最短路都是怎么过的）

　　下面贴完整代码：

　

#include <bits/stdc++.h>
#define ll long long
#define pil pair<int,ll>
using namespace std;
 
const int maxn=1e5+5;
bool vis[maxn];
int n,m,k,ind[maxn];
ll dis[maxn],minn[maxn];
vector<pil>G[maxn];
 
 
struct cmp {
    bool operator()(pil a, pil b) {
        return a.second > b.second;
    };
};
 
 
    void dij() {
        fill(dis, dis + maxn, 1e18);
        priority_queue<pil, vector<pil >, cmp> pq;
        pq.push({1, 0});
        dis[1] = 0;
        while (!pq.empty()) {
            int now = pq.top().first;
            pq.pop();
            if (vis[now]) continue;
            vis[now] = 1;
            for (int i = 0; i < G[now].size(); ++i) {
                int to = G[now][i].first,
                        v = G[now][i].second;
 
                if (!vis[to] && dis[to] > dis[now] + v) {
                    ind[to] = 1;
                    dis[to] = dis[now] + v;
                    pq.push({to, dis[to]});
                } else if (dis[to] == dis[now] + v) ++ind[to];
            }
        }
    }
 
    int main() {
        ios::sync_with_stdio(0);
        cin >> n >> m >> k;
        for (int i = 1; i <= m; ++i) {
            int a, b, c;
            cin >> a >> b >> c;
            G[a].push_back({b, c});
            G[b].push_back({a, c});
        }
        int ans = 0;
        for (int i = 1; i <= k; ++i) {
            int a;
            ll b;
            cin >> a >> b;
            if (minn[a]) {
                ++ans;
                minn[a] = min(minn[a], b);
            } else minn[a] = b;
        }
        for (int i = 2; i <= n; ++i) {
            if (minn[i]) {
                G[1].push_back({i, minn[i]});
                G[i].push_back({1, minn[i]});
            }
        }
        dij();
        for (int i = 2; i <= n; ++i) {
            if (minn[i]) {
                if (minn[i] > dis[i]) {
                    ++ans;
                }
                if (minn[i] == dis[i] && ind[i] > 1)++ans;
            }
        }
        cout << ans << endl;
    }

还要注意的是：最短路图的入度是在Dij的过程中确定的，更新一次后(dis[to]>dis[now]+v),to的入度变为1，如果(dis[to]==dis[now]+v),to的入度+1

　　　　　　　　确定入度和最短路计数也不太一样，计数时，更新一次后(dis[to]>dis[now]+v),to的入度变为indegree[now],如果(dis[to]==dis[now]+v),indegree[to]+indegree[now]

B - Phillip and Trains

　　BFS/DFS水题，注意一下人的运动要先前进一格在上下移动，不可以先上下移动再前进一格，开始没读好题

　　

#include<bits/stdc++.h>
#define pii pair<int,int>
using namespace std;
int start;
 
const int maxn=1e3+5;
char plat[5][maxn];
bool vis[5][maxn];
int n;
int all_f;
bool move(int x,int y)
{
    return plat[x][y+1]=='.' && plat[x][y+2]=='.';
}
bool bfs()
{
    queue<pii>q;
    q.push({start,1});
    while(!q.empty())
    {
        pii now=q.front();
        q.pop();
        int x=now.first,y=now.second;
        if(y>=n) return 1;
        if(vis[x][y]) continue;
        vis[x][y]=1;
        if(plat[x][y+1]!='.') continue;
        for(int i=-1;i<=1;++i)
        {
            if(plat[x+i][y+1]=='.' && move(x+i,y+1))
            {
                q.push({x+i,y+3});
            }
        }
    }
    return 0;
}
int main()
{
    int t;
    ios::sync_with_stdio(0);
    cin>>t;
    while(t--)
    {
        all_f=0;
        memset(plat,0,sizeof(plat));
        memset(vis,0,sizeof(vis));int no;
        cin>>n>>no;
        cin>>plat[1]+1>>plat[2]+1>>plat[3]+1;
        for(int i=1;i<=3;++i)
        {
            for(int j=1;j<=n;++j)
            {
                if(plat[i][j]=='s') start=i;
                plat[i][j+n]='.';
            }
        }
        cout<<(bfs()?"YES":"NO")<<endl;
    }
}

C - A Mist of Florescence

　　给4个数abcd表示ABCD四个字母连通块的个数，构造一个矩阵使其ABCD连通块的个数为abcd

　　构造+思维，

　　排序以下，由小到大分别为ABCD，ABC各拿出来一个，先ABABAB排，用C个开一层，再用B隔开一层，再CDCDCD排，A隔开然后BDBDBD排，最后剩下的B/D嵌到A中。

　　

#include<bits/stdc++.h>
#define pii pair<int,int>
using namespace std;
int a,b,c,d;
int ans[51][51];
pii blo[10];
int main()
{
    for(int i=1;i<=4;++i) cin>>blo[i].first,blo[i].second=i;
    sort(blo+1,blo+1+4);
    a=blo[1].first,b=blo[2].first,c=blo[3].first,d=blo[4].first;
    --a,--b,--c;
    int minn=a;
    int col=1,row=1;
    b-=a;
    while(a)
    {
        if(row&1)
        {
            ans[row][col++]=1;
            ans[row][col++]=2;
        }
        else
        {
            ans[row][col++]=2;
            ans[row][col++]=1;
        }
        --a;
        if(col==51)
        {
            col=1;
            ++row;
        }
    }
    for(int i=col;i<=50;++i) ans[row][i]=3;
    for(int i=1;i<=50;++i) ans[row+1][i]=3;
    for(int i=1;i<=50;++i) ans[row+2][i]=2;
    minn=c;
    row+=3,col=1;
    d-=c;
    while(c)
    {
        if(row&1)
        {
            ans[row][col++]=3;
            ans[row][col++]=4;
        }
        else
        {
            ans[row][col++]=4;
            ans[row][col++]=3;
        }
        --c;
        if(col==51)
        {
            col=1;
            ++row;
        }
    }
    
    for(int i=col;i<=50;++i) ans[row][i]=1;
    for(int i=1;i<=50;++i) ans[row+1][i]=1;
    row+=2;col=1;
    minn=min(b,d);
    int bb=b,dd=d;
    while(minn)
    {
        //cout<<"Q"<<endl;
        if(row&1)
        {
            ans[row][col++]=2;
            ans[row][col++]=4;
        }
        else
        {
            ans[row][col++]=4;
            ans[row][col++]=2;
        }
        --minn;
        if(col==49)
        {
            col=1;
            ans[row][49]=1;
            ans[row][50]=1;
            ++row;
        }
    }
    for(int i=col;i<=50;++i) ans[row][i]=1;
    ++row;
    for(int i=1;i<=50;++i) ans[row][i]=1;
    ++row;
    int red=abs(b-d);
    col=1;
    while(red)
    {
        --red;
        ans[row][col++]=7;
        ans[row][col++]=1;
        if(col==51) 
        {
            col=1,++row;
            for(int i=1;i<=50;++i) ans[row][i]=1;
            ++row;
        }
    }
    for(int i=col;i<=50;++i) ans[row][i]=1;
    int p=bb>dd?2:4;
    for(int i=1;i<=50;++i)
    {
        for(int j=1;j<=50;++j)
        {
            if(ans[i][j]==7) ans[i][j]=p;
        }
    }
    cout<<row<<" "<<50<<endl;
    for(int i=1;i<=row;++i)
    {
        for(int j=1;j<=50;++j)
        {
            //cout<<ans[i][j];
            printf("%c",'A'-1+blo[ans[i][j]].second);
        }
        puts("");
    }
    cout<<endl;
}

　　

D - Unbearable Controversy of Being

　　给一个有向图，问图中有多少个图示单元。

　　思维+遍历图+水题

　　对于每个起始点，找到深度所有为2的点，每个点出现次数计数一下，复杂度O(n^2),答案为每个数的C（cnt，2）求和。

　　

#include<bits/stdc++.h>
long long ans=0;
using namespace std;
const int maxn=4000;
inline int cnt(int n){return n*(n-1)/2;}
int n,m,vis[maxn];
vector<int>G[maxn];
void dfs(int now,int dep)
{
    if(dep==2)
    {
        ++vis[now];
        return;
    }
    for(int i=0;i<G[now].size();++i)
    {
        int to=G[now][i];
        dfs(to,dep+1);
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin>>n>>m;
    for(int i=1;i<=m;++i)
    {
        int a,b;cin>>a>>b;
        G[a].push_back(b);
    }

    for(int i=1;i<=n;++i)
    {
        memset(vis,0,sizeof(vis));
        dfs(i,0);
        for(int j=1;j<=n;++j)
        {
            if(j==i) continue;
            //cout<<vis[j]<<" ";
            if(vis[j]>1)
            ans+=cnt(vis[j]);
        }
        //cout<<endl;
    }
    cout<<ans<<endl;
}

E水题

F水题

G - New Year Permutation

思维+并查集+个人SB错误（关了流同步用getchar）

对于每个可以交换的数字集合，按照元素大小排序，到元素对应的集合的时候，从小到大依次取出就ok

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3;
int fa[maxn],a[maxn];
char plat[maxn][maxn];
int n;
int findx(int x)
{
    return x==fa[x]?x:fa[x]=findx(fa[x]);
}
vector<int>per[maxn];
int cnt[maxn],tmp[maxn];
int main()
{
    //ios::sync_with_stdio(0);
    for(int i=1;i<maxn;++i) fa[i]=i;
    cin>>n;
    for(int i=1;i<=n;++i)
    {
        cin>>a[i];
    }
    
    for(int i=1;i<=n;++i)
    {
        cin>>plat[i]+1;
        for(int j=1;j<=n;++j)
        {
            if(plat[i][j]=='1')
            {
                int a=findx(i),b=findx(j);
                if(a!=b)
                {
                    fa[b]=a;
                }
            }
        }
    }
    for(int i=1;i<=n;++i) tmp[i]=a[i];
    for(int i=1;i<=n;++i)
    {
        int t=findx(i);
        per[t].push_back(i);
    }
    for(int i=1;i<=n;++i)
    {
        sort(per[i].begin(),per[i].end(),[](int x,int y){return a[x]<a[y];});
    }
    
    for(int i=1;i<=n;++i)
    {
        int t=findx(i);
        cout<<a[per[t][cnt[t]++]]<<" ";
    }
}

H - Alyona and the Tree

树形dp+思维+深度遍历图

　　每个点和每个边都有权值，当两点距离大于子节点长度时，删掉子节点，问最少删除子节点数量

开始没想明白，，，后来发现：设祖先为X，对于每个子节点的len(X,v),如果这个值小于0，那么从这个字节点开始到它的子节点v',肯定有len(X,v')<len(v,v'),所以维护一个max(0,len(X,v))就可以，当这个值大于子节点权值，删掉子节点，如果子节点不是叶子节点，则移除整棵子树。

#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
using namespace std;
const int maxn=1e5+5;
int a[maxn];
int n,ans;
vector<pii>G[maxn];
void dfs(int fa,int now,ll maxx)
{
    if(maxx>a[now]) return;
    for(int i=0;i<G[now].size();++i)
    {
        int to=G[now][i].first,v=G[now][i].second;
        if(to==fa) continue;
        dfs(now,to,max(maxx+v,1ll*0));
    }
    ++ans;
}
int main()
{
    ios::sync_with_stdio(0);
    cin>>n;
    for(int i=1;i<=n;++i) cin>>a[i];
    for(int i=2;i<=n;++i)
    {
        int q,w;cin>>q>>w;
        G[i].push_back({q,w});
        G[q].push_back({i,w});
    }
    dfs(-1,1,0);
    cout<<n-ans;;
}

J - Resort

　　给一个有向图，一些点是特殊点，要求一条最长链使得这条链起点为普通点，终点为特殊点，输出这条链（因为是链所以要求每个普通点出度均为1）。

　　一开始想复杂了。。。

　　根据输入我们可以注意到：一个点可以有多条出边，但是最多只有只有一条入边！

　　所以，我们反向建图：对于每个点，可能有多条入边，但是只能有一条出边

　　而且对于每个普通点，满足条件的话要保证其源头只有一个特殊点（此时入度为题目中出度，即保证出度为1），所以每个只被遍历一次，复杂度O(n)。

　　然后找到最长的输出即可

　　

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int in[maxn];
vector<int>G[maxn],ans[maxn];
int n,hot[maxn];

void dfs(int h,int now)
{
    ans[h].push_back(now);
    if(G[now].size())
    {
        int to=G[now][0];
        if(hot[to]) return;
        if(in[to]>1) return;
        dfs(h,to);
    }
}
int main()
{
    ios::sync_with_stdio(0);cin>>n;
    for(int i=1;i<=n;++i) cin>>hot[i];
    for(int i=1;i<=n;++i)
    {
        int t;cin>>t;
        if(t) G[i].push_back(t);
        ++in[t];
    }
    for(int i=1;i<=n;++i)
    {
        if(hot[i]) dfs(i,i);
    }
    int maxx=0,maxi;
    for(int i=1;i<=n;++i)
    {
        if(maxx<ans[i].size())
        {
            maxx=ans[i].size();
            maxi=i;
        }
    }
    cout<<maxx<<endl;
    reverse(ans[maxi].begin(),ans[maxi].end());
    for(int t:ans[maxi])
    cout<<t<<" ";
}

L假的三元环

M读清题就会做

N并查集随便搞搞就可以

Odfs二分图染色一下就ok，复杂度O(n)

#include <bits/stdc++.h>
#define pii pair<int,int>
using namespace std;
const int maxn=2e5+5;
vector<int>G[maxn];
int n,m;
int vis[maxn];
inline int no(int a)
{
    return a==1?0:1;
}
void dfs(int fa,int now,int color)
{
    for(int to:G[now])
    {
        if(to==fa) continue;
        if(vis[to]==-1)
        {
            vis[to]=no(color);
            dfs(now,to,no(color));
        } else{
            if(vis[to]==color)
            {
                cout<<"-1";
                exit(0);
            }
            else;
        }
    }
}
int main()
{
    memset(vis,-1,sizeof(vis));
    ios::sync_with_stdio(0);
    cin>>n>>m;
    for(int i=1;i<=m;++i)
    {
        int a,b;cin>>a>>b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    for(int i=1;i<=n;++i)
    {
        if(G[i].size()>0 && vis[i]==-1)
        {
            vis[i]=1;
            dfs(-1,i,1);
        }
    }
    int num1=0,num0=0;
    for(int i=1;i<=n;++i)
    {
        if(vis[i]==0) ++num0;
        if(vis[i]==1) ++num1;
    }
    cout<<num0<<endl;
    for(int i=1;i<=n;++i) if(vis[i]==0) cout<<i<<" ";
    cout<<endl;
    cout<<num1<<endl;
    for(int i=1;i<=n;++i)
    {
        if(vis[i]==1) cout<<i<<" ";
    }
    cout<<endl;;
}

总结：

　　1.我不会子写dijkstra  hhhhh（现在会了），对dij有了更深的了解

　　      （1）开始的写法是假堆，（2）不判断是否入队会T飞（或者队列巨长MLE）（3）队列元素是边数级别的

　　2.

　　　　读题很重要！

　　  读题很重要！

　　  读题很重要！　　

　　读题没读好细节就开始瞎jb写导致WA好几发

　　3.写代码要专心，否则后果就是debug+思路混乱+效率低

　　4.注意long long  （*1）

　　5.图论题能不能发现一下题意中隐藏的一些性质呢？（H，J）