2015 ACM/ICPC Asia Regional Shenyang Online

最新推荐文章于 2019-04-26 23:55:23 发布
最新推荐文章于 2019-04-26 23:55:23 发布
阅读量1k 收藏
点赞数
分类专栏： 比赛总结 文章标签： 比赛总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ok_again/article/details/48685921
版权

补题。

A-Traversal

占坑

B-Best Solver

这题当时是队友敲的，但是好像是这样的：（以下搬自_）

考虑
这个很容易让人想到二阶常系数线性递推，根据伟达定理容易知道
因为系数都是整数，而且考虑到 ，故 即 的整数部分。

上面那个式子可以用矩阵快速幂求，然后2^x很大，就猜肯定有循环节，然后就打了一个循环节的表交上去了。代码就不粘了，太长了。

其实循环节都可以用  。

C-Minimum Cut

这题让求的是树上的边只删一条，然后求删掉最少的边使得图不连通。于是考虑树上每条边，如果删掉这条边的话，肯定需要删掉跨过这条边的所有边。显然可以用非树边（u,v）去更新u->v这条路径上所有的边权值+1，然后树链剖分随便做一下。用的bin神的模板，跑的快快的。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const int MAXN = 100010;
struct Edge
{
    int to,next;
} edge[MAXN*2];
int head[MAXN],tot;
int top[MAXN];
int fa[MAXN];
int deep[MAXN];
int num[MAXN];
int p[MAXN];
int fp[MAXN];
int son[MAXN];
int pos;
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
    pos = 1;
    memset(son,-1,sizeof(son));
}
inline void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
inline void dfs1(int u,int pre,int d)
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != pre)
        {
            dfs1(v,u,d+1);
            num[u] += num[v];
            if(son[u] == -1 || num[v] > num[son[u]])
                son[u] = v;
        }
    }
}
inline void getpos(int u,int sp)
{
    top[u] = sp;
    p[u] = pos++;
    fp[p[u]] = u;
    if(son[u] == -1)return;
    getpos(son[u],sp);
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v,v);
    }
}
long long w1[MAXN];
void add1(int u,int v,int w)
{
    int f1 = top[u],f2 = top[v];
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        w1[p[f1]] += w;
        w1[p[u]+1] -= w;
        u = fa[f1];
        f1 = top[u];
    }
    if(deep[u] > deep[v])swap(u,v);
    w1[p[u]] += w;
    w1[p[v]+1] -= w;
}
long long w2[MAXN];
void add2(int u,int v,int w)
{
    int f1 = top[u], f2 = top[v];
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        w2[p[f1]] += w;
        w2[p[u]+1] -= w;
        u = fa[f1];
        f1 = top[u];
    }
    if(u == v)return;
    if(deep[u] > deep[v])swap(u,v);
    w2[p[son[u]]] += w;
    w2[p[v]+1] -= w;
}
//适用于正负整数
template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if(c=getchar(),c==EOF) return 0; //EOF
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}

inline void out(long long x)
{
    if(x>9) out(x/10);
    putchar(x%10+'0');
}
pair<int,int>pp[MAXN];
int link[MAXN];
int ans1[MAXN],ans2[MAXN];
int main()
{
    int n,m;
    int T;
    int iCase = 0;
    scanf("%d",&T);
    while(T--)
    {
        iCase++; init();
        scan_d(n); scan_d(m);
        memset(w1,0,sizeof(w1));
        memset(w2,0,sizeof(w2));
        int u,v,w;
        for(int i = 1; i < n; i++)
        {
            scan_d(u);
            scan_d(v);
            addedge(u,v);
            addedge(v,u);
            pp[i] = make_pair(u,v);
        }
        dfs1(1,0,0);
        getpos(1,1);
        for(int i = 1; i < n; i++)
        {
            if(deep[pp[i].first] > deep[pp[i].second])
                swap(pp[i].first,pp[i].second);
            link[pp[i].second] = i;
        }
        for(int i = n; i <= m; i ++)
        {
            scanf("%d%d", &u, &v);
            add2(u, v, 1);
        }
        for(int i = 1; i <= n; i++)
        {
            w2[i] += w2[i-1];
            ans2[link[fp[i]]] = w2[i];
        }
        printf("Case #%d: ",iCase);
        int ans = m;
        for(int i = 1; i < n; i++)
        {
            ans = min(ans, ans2[i]);
        }
        printf("%d\n", ans + 1);
    }
    return 0;
}

D- Dividing This Product

这题据说有一个很诡异复杂度的方法。然后我们看到数据只有10个，然后就把后台数据二分出来了。。然后就暴力打了个表。。。没错，错164次那个就是我们！

据说还可以分段打表。因为交的是数据，所以就不贴代码了，影响和谐。

E-Excited Database

占坑

F-Fang Fang

签到题，注意可能出现别的字符。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const int maxn = 1001000;

char ch[maxn];
int n;

bool check()
{
    int l = -1;
    for(int i = 0; i < n; i ++)
    {
        if(ch[i] != 'c' && ch[i] != 'f') return false;
        if(ch[i] == 'c')
        {
            if(l != -1 && l + 2 >= i) return false;
            l = i;
        }
    }
    if(l == -1) return true;
    int r = 0;
    while(ch[r] != 'c') r ++;
    int num = n - l + r - 1;
    if(num < 2) return false;
    return true;
}

void solve()
{
    n = strlen(ch);
    if(!check())
    {
        puts("-1");
        return ;
    }
    int cnt = 0;
    for(int i = 0; i < n; i ++)
    {
        if(ch[i] == 'c') cnt ++;
    }
    if(cnt == 0) cnt = (n + 1) / 2;
    printf("%d\n", cnt);
}

int main()
{
    int T, cas = 1;
    scanf("%d", &T);
    while(T --)
    {
        scanf("%s", ch);
        printf("Case #%d: ", cas ++);
        solve();
    }
    return 0;
}
G- Matches Puzzle Game

挺恶心的dp，先把减法转化成加法比较容易写。dp[i][j][k][s]表示还剩i个火柴的时候，j=1表示加数当前位出现过，k=1表示加数当前出现了，s=1表示需要后面的进位。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const int maxn = 555;

LL dp[maxn][2][2][2];

int c[12] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6, 6};
///          0  1  2  3  4  5  6  7  8  9
int n, m;

void solve()
{
    CLR(dp, 0);
    n -= 3;
    dp[n][0][0][0] = 1;
    dp[n - c[1]][0][0][1] = 1;
    for(int j = n; j >= 0; j --)
    {
        for(int a1 = 0; a1 <= 9; a1 ++)
        {
            int lft = j - 2 * c[a1];
            if(lft >= 0)
            {
                dp[lft][0][1][0] = (dp[lft][0][1][0] + dp[j][0][1][0]) % m;
                if(j == n && a1)
                    dp[lft][0][1][0] = (dp[lft][0][1][0] + dp[j][0][0][0]) % m;
                dp[lft][1][0][0] = (dp[lft][1][0][0] + dp[j][1][0][0]) % m;
                if(j == n && a1)
                    dp[lft][1][0][0] = (dp[lft][1][0][0] + dp[j][0][0][0]) % m;
            }
            lft = j - c[a1] - c[a1 + 1];
            if(lft >= 0)
            {
                int cr = (a1 + 1) / 10;
                dp[lft][0][1][1] = (dp[lft][0][1][1] + dp[j][0][1][cr]) % m;
                if(((cr && j == n - c[1]) || (cr == 0 && j == n)) && a1)
                    dp[lft][0][1][1] = (dp[lft][0][1][1] + dp[j][0][0][cr]) % m;
                dp[lft][1][0][1] = (dp[lft][1][0][1] + dp[j][1][0][cr]) % m;
                if(((cr && j == n - c[1]) || (cr == 0 && j == n)) && a1)
                    dp[lft][1][0][1] = (dp[lft][1][0][1] + dp[j][0][0][cr]) % m;
            }
            for(int a2 = 0; a2 <= 9; a2 ++)
            {
                lft = j - c[a1] - c[a2] - c[(a1 + a2) % 10];
                if(lft >= 0)
                {
                    int cr = (a1 + a2) / 10;
                    dp[lft][1][1][0] = (dp[lft][1][1][0] + dp[j][1][1][cr]) % m;
                    if(((cr && j == n - c[1]) || (cr == 0 && j == n)) && a1 && a2)
                    {
                        dp[lft][1][1][0] = (dp[lft][1][1][0] + dp[j][0][0][cr]) % m;
                    }
                    if(a2) dp[lft][1][1][0] = (dp[lft][1][1][0] + dp[j][0][1][cr]) % m;
                    if(a2) dp[lft][1][1][0] = (dp[lft][1][1][0] + dp[j][1][0][cr]) % m;
                }
                lft = j - c[a1] - c[a2] - c[(a1 + a2 + 1) % 10];
                if(lft >= 0)
                {
                    int cr = (a1 + a2 + 1) / 10;
                    dp[lft][1][1][1] = (dp[lft][1][1][1] + dp[j][1][1][cr]) % m;
                    if(((cr && j == n - c[1]) || (cr == 0 && j == n)) && a1 && a2)
                        dp[lft][1][1][1] = (dp[lft][1][1][1] + dp[j][0][0][cr]) % m;
                    if(a2) dp[lft][1][1][1] = (dp[lft][1][1][1] + dp[j][1][0][cr]) % m;
                    if(a2) dp[lft][1][1][1] = (dp[lft][1][1][1] + dp[j][0][1][cr]) % m;
                }
            }
        }
    }
//    printf("%lld ---\n", dp[n - c[1]][0][0][1]);
    printf("%I64d\n", dp[0][1][1][0]);
}

int main()
{
    int T, cas = 1;
    scanf("%d", &T);
    while(T --)
    {
        scanf("%d%d", &n, &m);
        printf("Case #%d: ", cas ++);
        solve();
    }
    return 0;
}

H- Hold Your Hand

占坑

I-Stability

这题正解比较诡异。我是用的树链剖分做的。首先肯定是倒着加边。然后维护一棵树，对于初始的树来说每条边肯定都是stability的，边权都赋为1，对于每个新加的边(u,v)，这个边肯定会把树上的路径u-v上的边都更新为0，这是显然的。然后就可以用树链剖分做了。然后直接交会超时，可以对线段树部分做个优化。因为每次都是对一个区间全赋0，那么就可以当当前区间都是0的时候就不用更新了。

初始树的形态是不会影响到答案的，这个很显然，因为加边形成的环的情况是不变的。而且如果一个边会被赋成0，则和形成环的顺序是无关的。

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const int MAXN = 100010;
struct Edge
{
    int to,next;
} edge[MAXN*2];
int head[MAXN],tot;
int top[MAXN], fa[MAXN], deep[MAXN], num[MAXN];
int p[MAXN], fp[MAXN], son[MAXN];
///p[u] = i(树上节点在线段树中位置),fp[i] = u(线段树上i点对应树上节点u)
int pos;
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
    pos = 1;
    memset(son,-1,sizeof(son));
}
inline void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
inline void dfs1(int u,int pre,int d)
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != pre)
        {
            dfs1(v,u,d+1);
            num[u] += num[v];
            if(son[u] == -1 || num[v] > num[son[u]])
                son[u] = v;
        }
    }
}
inline void getpos(int u,int sp)
{
    top[u] = sp;
    p[u] = pos++;
    fp[p[u]] = u;
    if(son[u] == -1)return;
    getpos(son[u],sp);
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v,v);
    }
}

int seg[MAXN<<2], tag[MAXN<<2];

void up(int rt)
{
    seg[rt] = seg[rt<<1] + seg[rt<<1|1];
}

void build(int l, int r, int rt)
{
    tag[rt] = 0;
    if(l == r)
    {
        seg[rt] = 1;
        return ;
    }
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
    up(rt);
}

void down(int rt)
{
    if(tag[rt])
    {
        seg[rt<<1] = seg[rt<<1|1] = 0;
        tag[rt<<1] = tag[rt<<1|1] = 1;
        tag[rt] = 0;
    }
}

void update(int L, int R, int l, int r, int rt)
{
    if(seg[rt] == 0) return ;
    if(L <= l && r <= R)
    {
        seg[rt] = 0;
        tag[rt] = 1;
        return ;
    }
    down(rt);
    int m = (l + r) >> 1;
    if(L <= m) update(L, R, lson);
    if(R > m) update(L, R, rson);
    up(rt);
}

int query(int L, int R, int l, int r, int rt)
{
    if(seg[rt] == 0) return 0;
    if(L <= l && r <= R)
    {
        return seg[rt];
    }
    down(rt);
    int ret = 0;
    int m = (l + r) >> 1;
    if(L <= m) ret += query(L, R, lson);
    if(R > m) ret += query(L, R, rson);
    return ret;
}

int n;

void add(int u,int v)  
{
    int f1 = top[u], f2 = top[v];
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        update(p[f1], p[u], 2, n, 1);
        u = fa[f1];
        f1 = top[u];
    }
    if(u == v)return;
    if(deep[u] > deep[v])swap(u,v);
    update(p[son[u]], p[v], 2, n, 1);
}
int ask(int u,int v)
{
    int f1 = top[u], f2 = top[v];
    int ret = 0;
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2])
        {
            swap(f1,f2);
            swap(u,v);
        }
        ret += query(p[f1], p[u], 2, n, 1);
        u = fa[f1];
        f1 = top[u];
    }
    if(u == v) return ret;
    if(deep[u] > deep[v])swap(u,v);
    ret += query(p[son[u]], p[v], 2, n, 1);
    return ret;
}
//适用于正负整数
pair<int,int>pp[MAXN];
int link[MAXN];

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if(c=getchar(),c==EOF) return 0; //EOF
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}

struct Qeury
{
    int op, u, v, ans;
    void inpt()
    {
        scan_d(op);
        scan_d(u);
        scan_d(v);
    }
} qrt[MAXN];

map<pair<int, int>, int> mp1;

int fat[MAXN];

int Find(int x)
{
    return fat[x] == x ? x : fat[x] = Find(fat[x]);
}

int main()
{
    int m,T,cas = 1, q;
    scan_d(T);
    while(T--)
    {
        init(); mp1.clear();
        scan_d(n); scan_d(m); scan_d(q);
        for(int i = 0; i < m; i ++)
        {
            int u, v;
            scan_d(u);
            scan_d(v);
            if(u == v) continue;
            if(u > v) swap(u, v);
            mp1[MP(u, v)] ++;
        }
        for(int i = 0; i < q; i ++)
        {
            qrt[i].inpt();
            if(qrt[i].op == 1)
            {
                int u = qrt[i].u, v = qrt[i].v;
                if(u == v) continue;
                if(u > v) swap(u, v);
                mp1[MP(u, v)] --;
                if(mp1[MP(u, v)] == 0)
                    mp1.erase(MP(u, v));
            }
        }
        map<pair<int, int>, int>::iterator it;
        for(int i = 1; i <= n; i ++)
            fat[i] = i;
        int e_cnt = 1;
        for(it = mp1.begin(); it != mp1.end(); it ++)
        {
            pair<int, int> e = it->xx;
            int fu = Find(e.xx), fv = Find(e.yy);
            if(fu == fv) continue;
            pp[e_cnt ++] = e;
            addedge(e.xx, e.yy);
            addedge(e.yy, e.xx);
            fat[fu] = fv; mp1[e] --;
        }
        dfs1(1,0,0);
        getpos(1,1);
        for(int i = 1; i < n; i++)
        {
            if(deep[pp[i].first] > deep[pp[i].second])
                swap(pp[i].first,pp[i].second);
            link[pp[i].second] = i;///每条边的深度大的点表示这个边!!
        }
        build(2, n, 1);
        for(it = mp1.begin(); it != mp1.end(); it ++)
        {
            if(it->yy == 0) continue;
            pair<int, int> e = it->xx;
            add(e.xx, e.yy);
        }
        for(int i = q - 1; i >= 0; i --)
        {
            int u = qrt[i].u, v = qrt[i].v, op = qrt[i].op;
            if(op == 1)
            {
                add(u, v);
            }
            else
            {
                qrt[i].ans = ask(u, v);
            }
        }
        printf("Case #%d:\n", cas ++);
        for(int i = 0; i < q; i ++)
        {
            if(qrt[i].op == 2) printf("%d\n", qrt[i].ans);
        }

    }
    return 0;
}


J-Jesus Is Here

这题显然ans[n]是可以通过ans[n-1]和ans[n-2]算出来的，其实就是将两个数列（每个数是相隔C的距离）拼起来，然后中间会产生一个新的数。然后写一下求和，然后更新一下答案就行了。中间需要用到sum1表示总和，sum2表示1C[1]+2C[2]......

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const LL MOD = 530600414;

const int maxn = 201314 + 10;

LL ans[maxn], sum1[maxn], sum2[maxn], sum3[maxn];
LL num[maxn];

void init()
{
    sum1[1] = sum2[1] = sum3[1] = 0;
    sum1[2] = sum2[2] = sum3[1] = 0;
    sum1[3] = sum2[3] = sum3[1] = 0;
    sum1[4] = sum2[4] = sum3[1] = 0;
    num[1] = 1; num[2] = 0;
    num[3] = 1; num[4] = 1;
    ans[1] = ans[2] = 0;
    ans[3] = ans[4] = 0;
    for(int i = 5; i < maxn; i ++)
    {
        ans[i] = (ans[i - 1] + ans[i - 2]) % MOD;
        int add = 3;
        if(i & 1) add = 5;
        ans[i] = (ans[i] + sum2[i - 2] * num[i - 1] % MOD) % MOD;
        ans[i] = (ans[i] + sum3[i - 1] * num[i - 2] % MOD) % MOD;
        ans[i] = (ans[i] + add * num[i - 1] % MOD * num[i - 2] % MOD) % MOD;
        num[i] = (num[i - 1] + num[i - 2]) % MOD;
        sum1[i] = (sum1[i - 1] + sum1[i - 2] + add) % MOD;
        sum2[i] = (sum2[i - 2] + sum2[i - 1] + add * num[i - 2] + (num[i - 2]) * sum1[i - 1] % MOD) % MOD;
        sum3[i] = (sum3[i - 1] + sum3[i - 2] + add * num[i - 1] + (num[i - 1]) * sum1[i - 2] % MOD) % MOD;
//        if(i <= 10) printf("%d - %lld %lld %lld %lld\n", i, num[i], sum1[i], sum2[i], ans[i]);
    }
}

int main()
{
    init();
    int T, cas = 1;
    scanf("%d", &T);
    while(T --)
    {
        int n; scanf("%d", &n);
        printf("Case #%d: %I64d\n", cas ++, ans[n]);
    }
}

K- Poker

占坑

L-Largest Point

签到题？不知道题意

//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define LL long long
#define MP make_pair
#define xx first
#define yy second
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1|1
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;

const int maxn=5005000;

LL t[maxn];

int main(){
    int T;scanf("%d",&T);
    for(int cas=1;cas<=T;cas++){
        LL a,b;
        int n;scanf("%d%I64d%I64d",&n,&a,&b);
        for(int i=0;i<n;i++) scanf("%I64d",&t[i]);
        sort(t,t+n);
        LL mx=a*t[0]*t[0]+b*t[1];
        for(int i=0;i<n;i++){
            LL now=a*t[i]*t[i];
            if(b<0){
                if(i) now+=b*t[0];
                else now+=b*t[1];
            }else{
                if(i==n-1) now+=b*t[n-2];
                else now+=b*t[n-1];
            }
            mx=max(mx,now);
        }
        printf("Case #%d: %I64d\n",cas,mx);
    }
}

M- Manors

占坑


ok_again
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
The 36th ACM/ICPC Asia Regional Shanghai Site —— Online Contest
09-10
The 36th ACM/ICPC Asia Regional Shanghai Site —— Online Contest Problem Set
hdu5461(2015 ACM/ICPC Asia Regional Shenyang Online)
baidu_30309461的博客
09-21 329
Given the sequence A with n integers t1,t2,⋯,tn. Given the integral coefficients a and b. The fact that select two elements ti and tj of A and i≠j to maximize the value of at2i+btj,
2015 ACM/ICPC Asia Regional Shenyang Online题解
海岛Blog
04-26 387
以下所有AC题解程序来自“仙客传奇”团队。 A. Traversal B. Best Solver AC的C++语言程序： #include <bits/stdc++.h> using namespace std; const int MAXN = 1e7 + 2; typedef long long ll; ll x , m; ll f[MAXN + 3], p, emmm[M...
2015 ACM/ICPC Asia Regional Shenyang Online(1002)
ZZ_AC的博客
09-19 424
Largest Point Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 294    Accepted Submission(s): 144 Problem Description Given the sequ
2015 ACM/ICPC Asia Regional Shenyang Online-1012 Largest Point
Some.
09-19 809
Largest Point Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 0    Accepted Submission(s): 0 Problem Description Given the sequence
ACM／ICPC的教学与实践
01-25
"ACM/ICPC的教学与实践" ACM/ICPC是国际大学生程序设计竞赛的缩写，全球公认的规模最大、水平最高的国际大学生程序设计竞赛。该项竞赛旨在使大学生运用计算机来充分展示自己分析问题和解决问题的能力。ACM/ICPC被...
The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest
09-03
The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest 注意，解压密码是：3.1415926535897932384
PowerOJ 是 ACM/ICPC 或 OI 的在线评委
最新发布
03-08
Online Judge 的存在为 ACM/ICPC（国际大学生程序设计竞赛）和 OI（信息学奥林匹克竞赛）等比赛提供了便利，使得参赛选手可以在线提交代码进行评测，节省了大量的时间和人力成本。同时，Online Judge 也为广大程序员...
THE 30th ACM/ICPC ASIA REGIONAL 2005 HANGZHOU SITE
07-26
THE 30th ACM/ICPC ASIA REGIONAL 2005 HANGZHOU SITE Onsite Contest Session 8:30am – 13:30pm, November 20th 2005 (GMT+8) <br>知道是什么了吧。。。
HDU 5455.Fang Fang【2015 ACM/ICPC Asia Regional Shenyang Online】【字符串处理】9月19
Mr丶Gao
09-19 486
Fang Fang Problem Description Fang Fang says she wants to be remembered. I promise her. We define the sequence F of strings. F0 = ‘‘f", F1 = ‘‘ff", F2 = ‘‘cff", Fn = Fn−1 + ‘‘f", for n 
【题解】 2015 ACM-ICPC Asia Regional Shenyang Online (3+1)
ACMer'
09-24 2072
【1006】 FangFang (暴力枚举) Fang Fang Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 871    Accepted Submission(s): 364 Problem Descr
2017 ACM/ICPC Asia Regional Shenyang Online [Cloned]超级简单的LIS
qq_40648801的博客
09-04 202
#include&lt;stdio.h&gt; int main() { int n,k,a[100005],b,l,r,top1,top2,mid,c[100005]; int t; scanf("%d",&amp;t); while(t--) { top1=0; top2=0; a[0]=999999;...
2015 ACM/ICPC 沈阳现场赛
w20810的专栏
11-01 1598
<题目链接>hdu
【索引】2015 ACM/ICPC Asia Regional Online
不慌不忙、不急不躁
10-02 2082
2015 ACM/ICPC Asia Regional Online Problem 1001: hdu 5484 Monitor the AlpacasProblem 1002: hdu 5485 The Relationship in ClubProblem 1003: hdu 5486 Difference of ClusteringProblem 1004
福州大学第十一届程序设计竞赛
ok_again的专栏
04-27 2445
福州大学第十一届程序设计竞赛 Contest Finished! Tag Pro.ID Problem Title Ratio(AC/Submit) 1 大王叫我来巡山呐 80.31%(261/325) 2 防守阵地 I 23.48%(193/822) 3 shadow 13.23%(97/733) 4
ACM-ICPC国际大学生程序设计竞赛北京赛区(2015)网络赛
ok_again的专栏
09-22 2427
补题。 A-The Cats' Feeding Spots 枚举圆心点，然后二分半径。注意圆的边上不能有点。 //#pragma comment(linker, "/STACK:1024000000,1024000000") #include #include #include #include #include #include #include #include #include #
推选文档ACMICPC国际大学生程序设计竞赛PPT.ppt
11-17
文档ACMICPC国际大学生程序设计竞赛PPT.ppt是关于ACM/ICPC国际大学生程序设计竞赛的推选文档。该竞赛始于1970年，是全球大学生计算机程序能力竞赛活动中最有影响的一项。竞赛采用赛区逐级选拔方式，每年来自全球各个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值