题解：2017-2018 ACM-ICPC, NEERC, Northern Subregional Contest

综述

Statements
Download
官方题解

第一次练习团队配合。五小时三人共做出ABCIK五题。配合有待加强。

A - Auxiliary Project

最开始是用DP做的。

#include<fstream>
using namespace std;
ifstream fin("auxiliary.in");
ofstream fout("auxiliary.out");
int work(int k)
{
    static int f[1000001]= {0},
        cost[10]= {6,2,5,5,4,5,6,3,7,6};
    if(k<0)return 0;
    if(f[k])return f[k];
    for(int i=0; i!=10; ++i)
        if(work(k-cost[i])>0||k==cost[i])
            f[k]=max(f[k],work(k-cost[i])+i);
    return f[k];
}
int main()
{
    int n;
    fin>>n;
    fout<<work(n);
}

其实这题可以贪心：尽量用性价比最高的7，多余的用4和1去补。

int work(int k)
{
    return k%3==1 ? k/3*7-3:
           k%3==2 ? k/3*7+1:
                    k/3*7;
}

B - Boolean Satisfability

做的时候没注意每个标识符长度为1，导致代码长了很多。

#include<fstream>
#include<string>
#include<set>
using namespace std;
ifstream fin("boolean.in");
ofstream fout("boolean.out");
set<string> b[3];
bool flag=1,sign=0;
int main()
{
    for(string s,ss; getline(fin,s,'|');)
    {
        while(!isalpha(s.back()))
            s.pop_back();//不加这个有的样例过不掉
        sign=s[0]=='~';
        ss=s.substr(sign);
        b[sign].insert(ss);
        if(b[!sign].find(ss)
                !=b[!sign].end())
            flag=0;
    }
    b[2].insert(b[0].begin(),b[0].end());
    b[2].insert(b[1].begin(),b[1].end());
    fout<<(1LL<<b[2].size())-flag;
}

可以用bitset和位运算弄个大新闻。

#include<fstream>
#include<bitset>
using namespace std;
ifstream fin("boolean.in");
ofstream fout("boolean.out");
bitset<'z'-'A'+1> b[3];
bool flag=1,sign=0;
int main()
{
    for(char ch; fin>>ch;)
    {
        if(isalpha(ch))
        {
            b[sign][ch-'A']=1;
            if(b[!sign][ch-'A'])
                flag=0;
            sign=0;
        }
        if(ch=='~')sign=1;
    }
    b[2]=b[0]|b[1];
    fout<<(1LL<<b[2].count())-flag;
}

C - Consonant Fencity

暴力dfs。
算consonant fencity的时候应当边搜索边计算，如果等搜索到达终点再从头计算会TLE。

#include<fstream>
#include<vector>
using namespace std;
ifstream fin("consonant.in");
ofstream fout("consonant.out");
string s,con("bcdfghjklmnpqrstvxz");
vector<vector<int> > adjmap(con.size(),vector<int>(con.size(),0));
vector<bool> state(con.size(),0),ans_state(con.size(),0);
int v=0,ans_v=0;
void dfs(int k)
{
    if(k==con.size())
    {
        if(ans_v<v)
        {
            ans_v=v;
            ans_state=state;
        }
        return;
    }
    dfs(k+1);
    state[k]=1;
    int t_v=v;
    for(int i=0; i!=con.size(); i++)
        if(i!=k)
            v+=(state[i]?-1:1)*adjmap[i][k];
    dfs(k+1);
    state[k]=0;
    v=t_v;
}
int main()
{
    fin>>s;
    for(int i=1,p=con.find(s[0]),q; i!=s.size(); ++i,p=q)
    {
        q=con.find(s[i]);
        if(p!=con.npos&&q!=con.npos)
        {
            ++adjmap[p][q];
            ++adjmap[q][p];
        }
    }
    dfs(0);
    for(int i=0,p; i!=s.size(); ++i)
    {
        p=con.find(s[i]);
        fout<<char(p!=con.npos&&ans_state[p]?
                   toupper(s[i]):s[i]);
    }
}

D - Dividing Marbles

留坑，网上的代码

#include<algorithm>  
#include <iostream>  
#include <stdlib.h>  
#include <string.h>  
#include  <stdio.h>  
#include   <math.h>  
#include   <time.h>  
#include   <vector>  
#include   <bitset>  
#include    <queue>  
#include      <set>  
#include      <map>  
using namespace std;  

int _,d1,d2,d3,d4,x,v;  
int pw[30],d[30];  
map<int,vector<int> > hs;  
int a[400];  
void dfs(int d) {  
    if (d>=3&&a[d-1]<1<<(d-3)) return;  
    for (int i=d-1;i>=0;i--) {  
        a[d]=a[i]+a[d-1];  
        if (a[d]<(1<<22)) {  
            int u=a[d],N=__builtin_popcount(u);  
            if (N<=4) {  
                int M=31-__builtin_clz(u);  
                if (d<N+M-1&&!hs.count(u)) {  
                    hs[u]=vector<int>(a,a+d+1);  
                }  
            }  
            dfs(d+1);  
        }  
    }  
}  
int main()  
{  
    freopen("dividing.in","r",stdin);  
    freopen("dividing.out","w",stdout);  
    a[0]=1;  
    dfs(1);  
    pw[0]=1;  
    for (int i=1;i<=25;i++) pw[i]=pw[i-1]*2;  
    for (scanf("%d",&_);_;_--) {  
        scanf("%d%d%d%d",&d1,&d2,&d3,&d4);  
        x=pw[d1]+pw[d2]+pw[d3]+pw[d4];  
        v=0;  
        for (int i=0;i<25;i++) if (x&pw[i]) {  
            d[v++]=i;  
        }  
        if (v!=4||!hs.count(x)) {  
            printf("%d\n",d[v-1]+v-1);  
            while (x!=1) {  
                printf("%d %d %d\n",x,x/2,x-x/2);  
                if (x%2==1) {  
                    printf("%d %d %d\n",x/2+1,x/2,1);  
                }  
                x/=2;  
            }  
        } else {  
            printf("%d\n",d[3]+2);  
            vector<int> w=hs[x];  
            for (int i=w.size()-1;i>=1;i--) {  
                printf("%d %d %d\n",w[i],w[i-1],w[i]-w[i-1]);  
            }  
        }  
    }  
    return 0;  
}  

E - Equal Numbers

这n个数第n-1次操作后全变成他们的最小公倍数。
有两种贪心策略：

1. 每次在未处理的数中选择出现次数最少的数变成最小公倍数。
2. 每次在倍数仍在这组数中的数中选择出现次数最少的数变成其倍数。

最优方案由以上两种策略产生。由于局部最优的方案不一定整体最优，因此将两种策略并行，每次输出其中最优的方案。

#include<fstream>
#include<vector>
#include<algorithm>
using namespace std;
ifstream fin("equal.in");
ofstream fout("equal.out");
vector<int> a,b,d(1e6+1,0);
int n;
int main()
{
    fin>>n;
    for(int i=0,t; i<n; ++i)
    {
        fin>>t;
        ++d[t];
    }
    for(int i=1; i<d.size(); ++i)
        if(d[i])
        {
            a.push_back(d[i]);
            for(int j=2*i; j<d.size(); j+=i)
                if(d[j])
                {
                    b.push_back(d[i]);
                    break;
                }
        }
    sort(a.begin(),a.end());
    sort(b.begin(),b.end());
    for(int i=0,p=0,q=0,sp=0,sq=0; i<=n; ++i)
    {
        while(p<a.size()&&sp+a[p]<=i)
            sp+=a[p++];
        while(q<b.size()&&sq+b[q]<=i)
            sq+=b[q++];
        fout<<a.size()-max(p-1,q)<<' ';
    }
}

F - Fygon 2.0

dfs。

#include<cstdio>
#include<map>
#include<bitset>
typedef long long ll;
typedef std::bitset<32> Bs;
Bs bs[32],t;
void add(char a,char b)
{
    a=(a=='1'?0:a-'a'+1);
    b=(b=='1'?0:b-'a'+1);
    bs[a][b]=1;
    bs[a][a]=1;
    bs[b][b]=1;
}
ll dfs(Bs x)
{
    static std::map<ll,ll> f;
    if(f.find(x.to_ulong())!=f.end())
        return f[x.to_ulong()];
    ll &ret=f[x.to_ulong()]=x.none();
    for(int i=0; i<32; ++i)
        if((x&bs[i])==(1<<i))
        {
            x[i]=0;
            ret+=dfs(x);
            x[i]=1;
        }
    return ret;
}
ll gcd(ll a,ll b)
{
    return b?gcd(b,a%b):a;
}
int main()
{
    freopen("fygon20.in","r",stdin);
    freopen("fygon20.out","w",stdout);
    int m;
    scanf("%d",&m);
    for(char a,b,c; m--;)
    {
        scanf(" for %c in range(%c, %c):",&a,&b,&c);
        add(b,a);
        add(a,c);
    }
    add('1','n');
    for(int i=0; i<32; ++i)
        for(int j=0; j<32; ++j)
            if(bs[j][i])
                bs[j]|=bs[i];
    for(int i=0; i<32; ++i)
    {
        if(bs[i].none())
            t[i]=1;
        for(int j=i+1; j<32; ++j)
            if(bs[i]==bs[j])
                t[j]=1;
    }
    ll an=dfs(t.flip()),ad=1,ag;
    for(int i=2; i<t.count()-1; ++i)ad*=i;
    ag=gcd(an,ad);
    printf("%d %lld/%lld",t.count()-2,an/ag,ad/ag);
}

G - Grand Test

网上代码，再研究

#include <bits/stdc++.h>  

using namespace std;  

using ll = long long;  
using db = double;  
using vi = vector<int>;  
#define pb push_back  
#define fir first  
#define sec second  
using pii = pair<int,int>;  

const int mxn = 100006;  

int n, m;  

vector<pii> edge;  
vi e[mxn];  

void sel(int lim) {  
    for (int i = 1; i <= n; ++i)  
        e[i] = {};  
    for (int i = 0; i <= lim; ++i) {  
        int x = edge[i].fir, y = edge[i].sec;  
        e[x].pb(y);  
        e[y].pb(x);  
    }  
}  

#define ass(x) ({if(!(x)) throw 1;})  
int dfn[mxn], cnt;  
int cactus(int x, int p) {  
    dfn[x] = ++cnt; int a = 0;  
    for (auto i : e[x]) if (i != p)  
        if (!dfn[i]) {  
            int t = cactus(i, x);  
            if (t && t != x) ass(!a), a = t;  
        } else if (dfn[i] < dfn[x]) {  
            ass(!a), a = i;  
        }  
    return a;  
}  

bool check(int lim) {  
    sel(lim);  
    try {  
        cnt = 0;  
        fill(dfn, dfn + n + 1, 0);  
        for (int i = 1; i <= n; ++i) if (!dfn[i])  
            cactus(i, 0);  

    } catch (...) {  
        return false;  
    }  
    return true;  
}  

bool v[mxn];  
vi st;  
void dfs(int x, int y) {  
    v[x] = true;  
    st.pb(x);  
    if (x == y)  
        throw 1;  
    for (auto i : e[x]) if (!v[i])  
        dfs(i, y);  
    st.pop_back();  
}  

int rid[mxn];  
vi pa;  
void dfs2(int x, int o) {  
    v[x] = true;  
    pa.pb(x);  
    if (x != o && rid[x])  
        throw 1;  
    for (auto i : e[x]) if (!v[i])  
        dfs2(i, o);  
    pa.pop_back();  
}  

void out(vi a) {  
    printf("%d", (int)a.size());  
    for (auto i : a)  
        printf(" %d", i);  
    puts("");  
}  

void out(vi a, int x, int y) {  
    rotate(a.begin(), find(a.begin(), a.end(), x), a.end());  
    out(vi(a.begin(), find(a.begin(), a.end(), y) + 1));  
}  

int main() {  
    freopen("grand.in", "r", stdin);  
    freopen("grand.out", "w", stdout);  

    int T;  
    cin >> T;  
    while (T--) {  
        scanf("%d%d", &n, &m);  
        edge = {};  
        for (int i = 0; i < m; ++i) {  
            int x, y;  
            scanf("%d%d", &x, &y);  
            edge.pb({x, y});  
        }  
        int L = 0, R = m - 1, M;  
        while (L < R)  
            if (M = L + R + 1 >> 1, check(M))  
                L = M;  
            else  
                R = M - 1;  

        // L : last legal  
        if (L == m - 1) {  
            puts("-1");  
        } else {  
            int p = L + 1;  
            sel(p - 1);  
            int x = edge[p].fir, y = edge[p].sec;  
            fill(v, v + n + 1, false);  
            st = {};  
            try { dfs(x, y); } catch (...) {}  
            assert(!st.empty() && st.front() == x && st.back() == y);  

            fill(rid, rid + n + 1, 0);  
            for (int i = 0; i < st.size(); ++i)  
                rid[st[i]] = i + 1;  

            for (int i = 1; i <= n; ++i)  
                e[i] = {};  
            for (int i = 0; i <= p - 1; ++i) {  
                int x = edge[i].fir, y = edge[i].sec;  
                if (!(rid[x] && rid[y] && abs(rid[x] - rid[y]) == 1)) {  
                    e[x].pb(y);  
                    e[y].pb(x);  
                }  
            }  

            fill(v, v + n + 1, false);  
            pa = {};  
            try {  
                for (int i = 1; i <= n; ++i) if (!v[i] && rid[i])  
                    dfs2(i, i);  
            } catch (...) {}  
            assert(!pa.empty() && rid[pa.front()] && rid[pa.back()] && pa.front() != pa.back());  

            x = pa.front();  
            y = pa.back();  
            printf("%d %d\n", x, y);  
            out(pa, x, y);  
            out(st, x, y);  
            reverse(st.begin(), st.end());  
            out(st, x, y);  
        }  
    }  

    return 0;
} 

H - Hidden Supervisors

#include <bits/stdc++.h>  

using namespace std;  

using ll = long long;  
using db = double;  
using vi = vector<int>;  
#define pb push_back  
#define fir first  
#define sec second  

const int maxn = 100006;   

vi e[maxn];   
int p[maxn];   
int n;   
bool mat[maxn];   
vi q;   

void dfs(int x) {  
    for (auto i : e[x]) {  
        dfs(i);   
        if (!mat[i] && !mat[x]) {  
            mat[x] = mat[i] = true;   
        }  
    }  
}  

void dfs2(int x) {  
    if (!mat[x]) q.pb(x);   
    for (auto i : e[x])   
        dfs2(i);   
}  

int tot;   
void dfs3(int x) {  
    if (!mat[x]) tot++;   
    for (auto i : e[x])   
        dfs3(i);   
}  
vector<pair<int,int>> S;   

int main() {  
    freopen( "hidden.in", "r", stdin );   
    freopen( "hidden.out", "w", stdout );   
    scanf( "%d", &n );   
    for (int i = 2; i <= n; ++i) {  
        scanf( "%d", &p[i] );  
        if (p[i] != 0) e[p[i]].pb(i);   
    }  
    for (int i = 1; i <= n; ++i)   
        if (p[i] == 0) dfs(i);   
    dfs2(1);   
    for (int i = 2; i <= n; ++i)   
        if (p[i] == 0 && mat[i]) {  
            p[i] = 1;   
            dfs2(i);   
        }  
    for (int i = 2; i <= n; ++i)   
        if (p[i] == 0) {  
            tot = 0;   
            dfs3(i);   
            S.pb( {tot,i} );   
        }  
    sort(S.begin(), S.end());   
    reverse(S.begin(), S.end());   
    for (auto x : S) {  
        int i = x.sec;   
        while (!q.empty() && mat[q.back()]) q.pop_back();   
        if (!q.empty()) {  
            mat[q.back()] = true;   
            mat[i] = true;   
            p[i] = q.back();   
            q.pop_back();   
        }  
        else p[i] = 1;   
        dfs2(i);  
    }  
    int ans = 0;   
    for (int i = 1; i <= n; ++i)   
        if (mat[i]) ans++;   
    cout<<ans/2<<endl;   
    for (int i = 2; i <= n; ++i) printf( "%d ", p[i] );   
    puts( "" );   
}  

I - Intelligence in Perpendicularia

求多边形多边形内部可以看到，但在外部看不到的线条长度。
只要拿总周长减去最小外接矩形周长即可。

#include<fstream>
using namespace std;
ifstream fin("intel.in");
ofstream fout("intel.out");
int n,ans=0,x[1024],y[1024];
int abs(int n)
{
    return n<0?-n:n;
}
int main()
{
    fin>>n;
    x[1023]=y[1023]=-1e7;
    x[1022]=y[1022]=1e7;
    for(int i=0; i!=n; ++i)
    {
        fin>>x[i]>>y[i];
        x[1023]=max(x[1023],x[i]);
        y[1023]=max(y[1023],y[i]);
        x[1022]=min(x[1022],x[i]);
        y[1022]=min(y[1022],y[i]);
    }
    for(int i=0; i!=n; ++i)
        ans+=abs(x[(i+1)%n]+y[(i+1)%n]-x[i]-y[i]);
    fout<<ans-2*(x[1023]+y[1023]-x[1022]-y[1022]);
}

J - Joker

分块维护。

//假装写了

K - Kotlin Island

样例是骗人的。例如，第二个样例其实不做任何处理就行。
其次，只要处理奇数行和奇数列（编号从0开始）即可。
f[i][j]表示将前i个奇数行和j个奇数列被充水后剩下的联通块数量，容易列出转移方程。转移的时候如果发现f[i][j]==n就可以输出了。

#include<fstream>
using namespace std;
ifstream fin("kotlin.in");
ofstream fout("kotlin.out");
int h,w,n,f[64][64]= {1,0};
int main()
{
    fin>>h>>w>>n;
    for(int i=0; 2*i<h; ++i)
        for(int j=0; 2*j<w; ++j)
        {
            if(i)f[i][j]=max(f[i][j],f[i-1][j]+j+1);
            if(j)f[i][j]=max(f[i][j],f[i][j-1]+i+1);
            if(f[i][j]==n)
            {
                for(int x=0; x<h; ++x,fout<<'\n')
                    for(int y=0; y<w; ++y)
                        fout<<((x%2&&x/2<i)||
                               (y%2&&y/2<j)?
                               '#':'.');
                return 0;
            }
        }
    fout<<"Impossible";
}

L - Little Difference

留。

ll n;  
bool base2(ll n)  
{  
    return (n&(-n))==n;  
}  
struct node  
{  
    ll a,b;  
    int aa,bb;  
} ans[N];  
int fun(ll a,ll b)//判断b是否是a的幂次  
{  
    int num=0;  
    while(b%a==0)  
    {  
        b/=a;  
        num++;  
    }  
    if(b!=1) num=-1;  
    return num;  
}  
int del()  
{  
    int num=0;  
//    if(n>1000000)  
        ans[num].a=n,ans[num].aa=1,ans[num++].bb=0;  
    for(ll i=2; i*i*i<=n; i++)  
    {  
        ll tmp=i;  
        for(int j=1; j<64; j++)  
            if(n%tmp==0)  
            {  
                ll other=n/tmp;  
                int num1=fun(i,other);  
                int num2=fun(i+1,other);  
                if(num1!=-1)  
                {  
                    ans[num].a=i,ans[num].aa=j+num1,ans[num++].bb=0;  
                    break;  
                }  
                if(num2!=-1)  
                {  
                    ans[num].a=i,ans[num].aa=j,ans[num].b=i+1,ans[num++].bb=num2;  
                    break;  
                }  
                if(n/tmp<i) break;  
                tmp*=i;  
            }  
    }  
    ll x=sqrt(n);  
//    if(x>1000000)  
//    {  
        if(x*x==n) ans[num].a=x,ans[num].aa=2,ans[num++].bb=0;  
        if(x*(x+1)==n) ans[num].a=x,ans[num].aa=1,ans[num].b=x+1,ans[num++].bb=1;  
//    }  
    return num;  
}  
void solve()  
{  
    int num=del();  
    printf("%d\n",num);  
    for(int i=0; i<num; i++)  
    {  
        printf("%d",ans[i].aa+ans[i].bb);  
        for(int j=0; j<ans[i].aa; j++) printf(" %lld",ans[i].a);  
        for(int j=0; j<ans[i].bb; j++) printf(" %lld",ans[i].b);  
        puts("");  
    }  
}  
int main()  
{  
    freopen("little.in ","r",stdin);  
   freopen("little.out","w",stdout);  
    while(~scanf("%lld",&n))  
    {  
        if(n==1||base2(n)) puts("-1");  
        else solve();  
    }  
    return 0;  
}