ACM-ICPC国际大学生程序设计竞赛北京赛区(2017)网络赛

编号	名称	通过率	通过人数	提交人数
A√水题（队友写的	Visiting Peking University	91%	1122	1228
B—	Reverse Suffix Array	57%	68	119
C最大子矩阵和	Matrix	51%	182	353
D缩点/二分/数位dp	Agent Communication	11%	23	209
E凸包	Territorial Dispute	57%	327	567
F—	Cake	15%	15	95
G√找规律	Bounce	74%	456	609
H—	Polynomial Product	51%	17	33
I√线段树	Minimum	77%	861	1110
J最短路	Typist's Problem	57%	44	77

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <sstream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define EPS 1e-8
#define MOD 1e9+7
#define max_ 1005
#define maxn 100

int p[max_];
bool vi[max_];
pair<int,int> c[max_];
int main()
{
    int n,m,q;
    while(~scanf("%d%d",&n,&m))
    {
        int length=;
        for(int i=;i<n;i++)
        {
            scanf("%d",&p[i]);
            vi[i]=true;
        }
        scanf("%d",&q);
        while(q--)
        {
            int c;
            scanf("%d",&c);
            vi[c]=false;
        }
        for(int i=;i<n;i++)
            if(vi[i])
            {
                c[length].first=p[i];
                c[length++].second=i;
            }
        int minn=INF;
        int aa,bb;
        for(int i=;i+m<=length;i++)
        {
            int x=c[i].first;
            for(int j=;j<m;j++)
            {
                if(c[i+j].first+x<minn)
                {
                    minn=c[i+j].first+x;
                    aa=c[i].second;
                    bb=c[i+j].second;
                }
            }
        }
        printf("%d %d\n",aa,bb);
    }
    return ;
}

A

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <sstream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define EPS 1e-8
#define MOD 1e9+7
#define max_ 270000

pair<int,int> tree[max_];
int minn,maxx;
void add(int rt,int l,int r,int v,int x)
{
    if(l==r)
        tree[rt].first=tree[rt].second=x;
    else
    {
        int mid=(l+r)>>;
        if(mid>=v)
            add(rt<<,l,mid,v,x);
        else
            add(rt<<|,mid+,r,v,x);
        tree[rt].first=min(tree[rt<<].first,tree[rt<<|].first);
        tree[rt].second=max(tree[rt<<].second,tree[rt<<|].second);
    }
}
void query(int rt,int l,int r,int L,int R)
{
    if(L>=l&&R<=r)
    {
        minn=min(minn,tree[rt].first);
        maxx=max(maxx,tree[rt].second);
    }
    else
    {
        int mid=(L+R)>>;
        if(mid>=l)
            query(rt<<,l,r,L,mid);
        if(mid<r)
            query(rt<<|,l,r,mid+,R);
    }
}
int main()
{
    int k;
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&k);
        int e=pow(,k);
        for(int i=;i<=e;i++)
        {
            int tmp;
            scanf("%d",&tmp);
            add(,,e,i,tmp);
        }
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int op;
            scanf("%d",&op);
            if(op==)
            {
                int l,r;
                scanf("%d%d",&l,&r);
                l++,r++;
                minn=INF,maxx=-INF;
                query(,l,r,,e);
                ll ans;
                if(minn>=)
                {
                    ans=minn;
                    ans*=ans;
                }
                else if(maxx>=)
                {
                    ans=minn;
                    ans*=maxx;
                }
                else
                {
                    ans=maxx;
                    ans*=maxx;
                }
                printf("%lld\n",ans);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                add(,,e,x+,y);
            }
        }
    }
    return ;
}

I

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int p[];
int l[];

struct Node
{
    int day;
    int cost;
}node[];

int main()
{
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        memset(l, , sizeof(l));
        for (int i = ; i < n; i++)
        {
            scanf("%d", &p[i]);
        }
        int ln,x;
        scanf("%d", &ln);
        for (int i = ; i < ln; i++)
        {
            scanf("%d", &l[i]);
        }
        sort(l, l + ln);
        int now = ;
        int now_node = ;
        for (int i = ; i < n; i++)
        {
            if (i == l[now]&&now<ln)
            {
                now++;
                continue;
            }
            node[now_node].day = i;
            node[now_node].cost = p[i];
            now_node++;
        }
        int min = 0x3f3f3f3f;
        int left = , right = ;
        for (int i = ; i <= now_node-m; i++)
        {
            for (int j = i + ; j < i + m; j++)
            {
                if (node[i].cost + node[j].cost < min)
                {
                    min = node[i].cost + node[j].cost;
                    left = node[i].day;
                    right = node[j].day;
                }
            }
        }
        printf("%d %d\n", left,right);
    }
}

A-2

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <sstream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define EPS 1e-8
#define MOD 1e9+7
#define max_ 270000
ll gcd(ll a,ll b)
{
    return b?gcd(b,a%b):a;
}
int main()
{
    ll xx,yy,cc,dd,n,a,b;
    while(~scanf("%lld%lld",&xx,&yy))
    {
        xx-=;
        yy-=;
        if(xx<yy) swap(xx,yy);
        n = xx*yy / gcd(xx,yy);
        a = n/yy;
        b = n/xx;
        if(b!=)
        {
            cc=(xx+yy-)/yy;
            dd=a-cc-cc+;
            if(b!=)
            {
                n-=(dd%(b-))*(b-);
                dd/=(b-);
                n-=dd*(b-)*(b-);
            }
            n-=(cc-)*(b-)*;
        }
        n++;
            printf("%lld\n",n);
    }
    return ;
}

G

#include <bits/stdc++.h>
#define mem(a,b) memset((a),(b),sizeof(a))
#define MP make_pair
#define pb push_back
#define fi first
#define se second
#define sz(x) x.size()
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const ll LLINF=0x3f3f3f3f3f3f3f3f;
const double PI=acos(-1.0);
const double eps=1e-;
const int MAX=2e5+;
const ll mod=1e9+;
int sgn(double x)
{
    if(fabs(x)<eps) return ;
    else return x>?:-;
}
struct Point
{
    int id;
    double x,y;
    Point(){}
    Point(double a,double b)
    {
        x=a;
        y=b;
    }
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
};
typedef Point Vector;
Vector operator -(Vector a,Vector b){return Vector(a.x-b.x,a.y-b.y);}
bool operator <(Point a,Point b){return a.x<b.x||(a.x==b.x&&a.y<b.y);}
bool operator ==(Point a,Point b){return sgn(a.x-b.x)==&&sgn(a.y-b.y)==;}
double dot(Vector a,Vector b){return a.x*b.x+a.y*b.y;}
double cross(Vector a,Vector b){return a.x*b.y-a.y*b.x;}
vector<Point> graham(vector<Point> p)
{
    int n,m,k,i;
    sort(p.begin(),p.end());
    p.erase(unique(p.begin(),p.end()),p.end());
    n=p.size();
    m=;
    vector<Point> res(n+);
    for(i=;i<n;i++)
    {
        while(m>&&cross(res[m-]-res[m-],p[i]-res[m-])<=) m--;
        res[m++]=p[i];
    }
    k=m;
    for(i=n-;i>=;i--)
    {
        while(m>k&&cross(res[m-]-res[m-],p[i]-res[m-])<=) m--;
        res[m++]=p[i];
    }
    if(n>) m--;
    res.resize(m);
    return res;
}
char ans[];
int main()
{
    int t,n,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        vector<Point> v;
        Point p[];
        for(i=;i<n;i++)
        {
            p[i].input();
            p[i].id=i;
            v.pb(p[i]);
        }
        if(n<=)
        {
            puts("NO");
            continue;
        }
        vector<Point> res=graham(v);
        mem(ans,);
        if(sz(res)==n)
        {
            if(n==)
            {
                puts("NO");
                continue;
            }
            int flag=;
            for(i=;i<sz(res);i++)
            {
                ans[res[i].id]='A'+flag;
                flag=(flag+)%;
            }
        }
        else
        {
            for(i=;i<sz(res);i++)
            {
                ans[res[i].id]='A';
            }
            for(i=;i<n;i++)
            {
                if(ans[i]!='A') ans[i]='B';
            }
        }
        ans[n]='\0';
        puts("YES");
        puts(ans);
    }
    return ;
}

E

#include<bits/stdc++.h>
#define rep(i,j,k) for((i)=(j);(i)<=(k);++i)
#define per(i,j,k) for((i)=(j);(i)>=(k);--i)
using namespace std;
typedef long long ll;
inline void cmin(ll &x,ll y){if(y<x)x=y;}
inline void cmax(ll &x,ll y){if(y>x)x=y;}
const ll N = ;
const ll inf = 1LL<<;
bool ok[N]; struct edge{ll v,next,w;}e[N];
ll dep[N],last[N],s[N],d[N],fa[N],id1[N],id2[N],K,L,n,i,l,r,u,v,w,cnt,top,stk[N];
ll inline read(){
    char ch=getchar();ll z=,f=;
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){z=z*+ch-'';ch=getchar();}
    return z*f;
}
void add(ll u,ll v,ll w){
    e[++cnt]=(edge){v,last[u],w};last[u]=cnt;
    e[++cnt]=(edge){u,last[v],w};last[v]=cnt;
}
void dfs(ll x,ll y,ll &mx){
    if(dep[x] > dep[mx]) mx = x; fa[x] = y; ll i;
    for(i=last[x];i;i=e[i].next)
        if(!ok[e[i].v] && e[i].v!=y){dep[e[i].v] = dep[x] + e[i].w; dfs(e[i].v,x,mx);}
}
ll getlength(ll root,ll &st,ll &ed,ll &len){
    dep[st = root] = ; dfs(root,,st); len = dep[st];
    dep[ed = st] = ; dfs(st,,ed);
    return dep[ed];
}
bool cmp1(ll x,ll y){return s[x]+d[x]<s[y]+d[y];}
bool cmp2(ll x,ll y){return s[x]-d[x]<s[y]-d[y];}
bool solve(ll K){
    ll i,j,k,l,p,q,mx=-inf,l1=-inf,r1=inf,l2=-inf,r2=inf;
    for(k=l=;k<=top;++k){
        j=id1[k]; while(l<=top && s[j]+d[j]-s[id2[l]]+d[id2[l]]>K){i=id2[l++]; cmax(mx,s[i]+d[i]);}
        if(l>){
            ll mi2=s[id2[]]-d[id2[]];
            l1=mx+s[top]+L-K;
            cmin(r1,mi2+s[j]-d[j]-L+K);
            l2=s[top]+L-K-mi2;
            cmin(r2,s[j]-d[j]-mx-L+K);
        }
    }
    if(l1>r1) return ; k = l = top; p = q = ;
    rep(i,,top)if(s[i]*>=l1+l2&&s[i]*<=r1+r2){
        while(k> && s[i]+s[k]>=l1) --k;
        while(l> && s[i]+s[l]>r1) --l;
        while(p<=top && s[i]-s[p]>=l2) ++p;
        while(q<=top && s[i]-s[q]>r2) ++q;
        if(max(q,k+)<=min(p-,min(l,i-))) return ;
    }
    return ;
}
int main()
{
    int t;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%lld",&n);
        L=;
        cnt = ; rep(i,,n) last[i] = ok[i] = ;
        rep(i,,n-){u=read();v=read();add(u,v,);}
        ll st,ed,len,l=-,r=getlength(,st,ed,len);
        stk[top = ok[ed] = ] = ed;
        for(i=ed;i!=st;i=fa[i]) ok[stk[++top] = fa[i]] = ;
        reverse(stk+,stk+top+);
        rep(i,,top) s[i] = dep[stk[i]];
        rep(i,,top) cmax(l,getlength(stk[i],st,ed,d[i])-);
        rep(i,,top) id1[i] = id2[i] = i;
        sort(id1+,id1+top+,cmp1);
        sort(id2+,id2+top+,cmp2);
        while(l+<r){
            K = l+r>>;
            if(solve(K)) r=K; else l=K;
        }
        printf("%lld\n",r);
    }
    return ;
}

D

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task2 solver = new Task2();
        int testCount = Integer.parseInt(in.next());
        for (int i = ; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Task2 {
        BigInteger C(int n, int m) {
            BigInteger ans = BigInteger.valueOf();
            for (int i = ; i <= m; i++) {
                ans = ans.multiply(BigInteger.valueOf(n - i + ));
            }
            for (int i = ; i <= m; i++) {
                ans = ans.divide(BigInteger.valueOf(i));
            }
            return ans;
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = new int[n + ];
            int[] b = new int[n + ];
            for (int i = ; i <= n; i++) {
                a[i] = in.nextInt();
                b[a[i]] = i;
            }
            ArrayList<Integer> arr = new ArrayList<>();
            int now = ;
            for (int i = ; i <= n; i++) {
                if (a[i - ] != n && (a[i] == n || b[a[i - ] + ] > b[a[i] + ])) {
                    arr.add(now);
                    now = ;
                } else {
                    now++;
                }
            }
            arr.add(now);
            if (arr.size() > ) {
                out.println();
            } else {
                int sz = arr.size();
                BigInteger[][] dp = new BigInteger[sz + ][];
                for (int i = ; i <= sz; i++) {
                    for (int j = ; j <= ; j++) {
                        dp[i][j] = BigInteger.valueOf();
                    }
                }
                dp[][] = BigInteger.valueOf();
                for (int i = ; i < sz; i++) {
                    for (int j = ; j < ; j++) {
                        for (int k = ; j + k <= ; k++) {
                            dp[i + ][j + k] = dp[i + ][j + k].add(dp[i][j].multiply(C(arr.get(i) + k - , k - )));
                        }
                    }
                }
                // out.println(dp[sz][26]);
                BigInteger ans = BigInteger.valueOf();
                for (int i = ; i <= ; i++) {
                    ans = ans.add(dp[sz][i]);
                }
                out.println(ans);
            }
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), );
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

B

B：java，26^3 dp，http://blog.csdn.net/skywalkert/article/details/51731556（在 cdoj 上也有一个

C：枚举上下界变成最大子段和，变成 dp[i][0..1]，C 直接卡上下界降维。开个数组记录下压缩这一列的最小值

 我是枚举上下边界然后单调栈 //

 dp[前i列][换了j次][有没有开始选区间]

二维rmq（×）

 你用单调栈就不用rmq了 

。

区间最小值就是
v[u][d][i]=min(v[u][d-1][i],a[d][i])
然后u d不用存

 就和一般的最大子矩阵和一样做

D：http://uoj.ac/problem/298（UOJ原题）抓一条直径，在上面选两个点连，二分答案之后考察可行性，点对的可行区域是一个菱形交（菱形交是百度之星原题）

（如果原本不能满足条件那么就要走这条新边

E：n<3 直接NO；n=3除了共线都是NO；n>=4 取前四个点 讨论一下就行

G：G 是个 TC 原题改，是数论。把这个图对偶一下，考察有多少个正方形被走过。发现是 (m-1)(n-1)/g^2，每个正方形内部一条对角线被走过，有 g-1 个。

J：J直接建图跑最短路，每条 1 边中间加个虚点拆成两个 0.5 就可以 BFS 了