2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest

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

A-Alex Origami Squares

水题。

//#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;

int main()
{
    freopen("alex.in", "r", stdin);
    freopen("alex.out", "w", stdout);
    double n, m;
    while(cin >> n >> m)
    {
        double mxx = 0;
        mxx = max(mxx, min(m, n / 3));
        mxx = max(mxx, min(n, m / 3));
        mxx = max(mxx, min(m / 2, n / 2));
        printf("%.3f\n", mxx);
    }
    return 0;
}

B- Black and White

不知道题意。

//#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;

int main () {
    freopen("black.in", "r", stdin);
    freopen("black.out", "w", stdout);
    int a, b;
    while(cin >> a >> b) {
        char x = '.';
        char y = '@';
        if(a < b) {
            swap(x, y);
            swap(a, b);
        }
//        printf("duo %c shao %c\n", x, y);
        b --;
        int dt = (a - b);
        a -= dt;
        int r = dt * 2 + 1 + a + b;
        int c = 2;
        printf("%d %d\n", r, c);
        printf("%c%c\n", x, x);
        for(int i = 0; i < dt; i ++) {
            printf("%c%c\n", x, y);
            printf("%c%c\n", x, x);
        }
        while(a || b) {
            if(b) printf("%c%c\n", y, y), b --;
            if(a) printf("%c%c\n", x, x), a --;
        }
    }
    return 0;
}

C- Concatenation

给两个字符串s1,s2，求s1的前缀和s2的后缀拼接可以有多少种不同的子串。

总数减去s2中的子串可以作为s1子串的个数就好了。这个可以用后缀数组实现。

//#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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 = 211111;

char ch1[maxn], ch2[maxn];
struct SuffixArray
{
    int r[maxn];
    int sa[maxn], rank[maxn], height[maxn];
    int t[maxn], t2[maxn], c[maxn], n;
    int m;
    void init(char* s)
    {
        n = strlen(s);
        for (int i = 0; i < n; i++) r[i] = int(s[i]);
        r[n] = 0;
        m = 300;
    }
    int cmp(int *r, int a, int b, int l)
    {
        return r[a] == r[b] && r[a + l] == r[b + l];
    }
    void build_sa()
    {
        int i, k, p, *x = t, *y = t2;
        r[n++] = 0;
        for (i = 0; i < m; i++) c[i] = 0;
        for (i = 0; i < n; i++) c[x[i] = r[i]]++;
        for (i = 1; i < m; i++) c[i] += c[i - 1];
        for (i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
        for (k = 1, p = 1; k < n; k *= 2, m = p)
        {
            for (p = 0, i = n - k; i < n; i++) y[p++] = i;
            for (i = 0; i < n; i++) if (sa[i] >= k) y[p++] = sa[i] - k;
            for (i = 0; i < m; i++) c[i] = 0;
            for (i = 0; i < n; i++) c[x[y[i]]]++;
            for (i = 1; i < m; i++) c[i] += c[i - 1];
            for (i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
            swap(x, y);
            p = 1;
            x[sa[0]] = 0;
            for (i = 1; i < n; i++) x[sa[i]] = cmp(y, sa[i - 1], sa[i], k) ? p - 1 : p++;
        }
        n--;
    }
    void getHeight()
    {
        int i, j, k = 0;
        for (i = 1; i <= n; i++) rank[sa[i]] = i;
        for (i = 0; i < n; i++)
        {
            if (k) k--;
            j = sa[rank[i] - 1];
            while (r[i + k] == r[j + k]) k++;
            height[rank[i]] = k;
        }
    }
    int d[maxn][20];
    void RMQ_init(int A[], int n)
    {
        for (int i = 1; i <= n; i++) d[i][0] = A[i];
        for (int j = 1; (1 << j) <= n; j++)
            for (int i = 1; i + (1 << (j - 1)) <= n; i++)
                d[i][j] = min(d[i][j - 1], d[i + (1 << (j - 1))][j - 1]);
    }
    int RMQ(int L, int R)
    {
        int k = 0;
        while ((1 << (k + 1)) <= R - L + 1) k++;
        return min(d[L][k], d[R - (1 << k) + 1][k]);
    }
    void LCP_init()
    {
        RMQ_init(height, n);
    }
    int lcp(int i, int j)
    {
        if(i == j) return 1;
        if (rank[i] > rank[j]) swap(i, j);
        return RMQ(rank[i] + 1, rank[j]);
    }
    void call_fun(char* s)
    {
        init(s);
        build_sa();
        getHeight();
        LCP_init();
    }
    LL solve(int len)
    {
        LL ret = 0;
        int l = 1, r = 0, tmp = 0;
        for(int i = 1; i <= n; i ++)
        {
            while(l < i && lcp(sa[l], sa[i]) == 0)
            {
                if(sa[l] > 0 && sa[l] < len) tmp --;
                l ++;
            }
            while(r < n && lcp(sa[i], sa[r + 1]) > 0)
            {
                r ++;
                if(sa[r] > 0 && sa[r] < len) tmp ++;
            }
            if(sa[i] >= len && sa[i] < n - 1) ret += tmp;
        }
        return ret;
    }
} sol;

void solve()
{
    int len1 = strlen(ch1), len2 = strlen(ch2);
    LL ans = 1ll * len1 * len2;
    ch1[len1 ++] = '#';
    for(int i = 0; i < len2; i ++)
    {
        ch1[len1 ++] = ch2[i];
    }
    ch1[len1] = 0;
    sol.call_fun(ch1);
    ans -= sol.solve(len1 - len2);
    printf("%I64d\n", ans);
}

map<string, int> mp;

void baoli()
{
    mp.clear();
    int len1 = strlen(ch1), len2 = strlen(ch2);
    string tmp = "";
    for(int i = 0; i < len1; i ++)
    {
        tmp += ch1[i];
        string tmp2 = "";
        for(int j = len2 - 1; j >= 0; j --)
        {
            tmp2 += ch2[j];
            reverse(tmp2.begin(), tmp2.end());
            mp[tmp + tmp2] ++;
            reverse(tmp2.begin(), tmp2.end());
        }
    }
    printf("%d -- \n", mp.size());
}
/**
hsdoisdfao
sdfjisdfjiosdfji

hsdo
sdfj
*/
int main()
{
    freopen("concatenation.in", "r", stdin);
    freopen("concatenation.out", "w", stdout);
    while(scanf("%s%s", ch1, ch2) != EOF)
    {
//        baoli();
        solve();
    }
    return 0;
}

D- Distribution in Metagonia

不知道题意。

//#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 xx first
#define yy second
#define LL unsigned long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;


int main ()
{
    int t;
    freopen("distribution.in", "r", stdin);
    freopen("distribution.out", "w", stdout);
    cin >> t;
    while(t --)
    {
        LL n;
        cin >> n;
        vector<LL> ans;
        while(n)
        {
            int cnt = 0;
            for(LL now = 2; ; now *= 2)
            {
                if(n % now) break;
                cnt ++;
            }
            LL tmp = 1ll << cnt;
            for(;;)
            {
                if(tmp * 3 <= n)
                {
                    tmp *= 3;
                }
                else
                {
                    break;
                }
            }
            ans.push_back(tmp);
            n -= tmp;
        }
        printf("%d\n", ans.size());
        LL o = 0;
        for(int i = 0; i < ans.size(); i ++)
        {
            printf("%I64u ", ans[i]);
            o += ans[i];
        }
        puts("");
    }
    return 0;
}


E- Easy Arithmetic

简单题。

#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;

char s[1024];
char num[1024];

int main(){
    freopen("easy.in","r",stdin);
    freopen("easy.out","w",stdout);
    while(scanf("%s",s)!=EOF){
        int n=strlen(s);
        for(int i=0;i<n;i++){
            if(s[i]=='+'){
                putchar(s[i]);
                int j;
                for(j=i+1;j<n&&s[j]<='9'&&s[j]>='0';j++) putchar(s[j]);
                i=j-1;
            }else if(s[i]=='-'){
                putchar(s[i]);
                int l=0,j;
                memset(num,0,sizeof(num));
                for(j=i+1;j<n&&s[j]<='9'&&s[j]>='0';j++) num[l++]=s[j];
                i=j-1;
                int st = l;
                putchar(num[0]);
                for(int j=1;j<l;j++){
                    if(num[j]=='0') printf("+%c",num[j]);
                    else{
                        putchar('+');st=j;break;
                    }
                }
                for(int j=st;j<l;j++) putchar(num[j]);
            }else putchar(s[i]);
        }
        puts("");
        memset(s,0,sizeof(s));
    }
}

G- Graph

题意是要最多+k条边使得字典序最小的拓扑序最大。

首先，对于当前度为0的点个数为sz，如果k>sz-1的话，是可以把最大那个点作为当前拓扑位置的，然后把比较小的那些非配一个未连入的度。否则如果存在未分配度的点u，大于当前度为0的点的话。可以把u放到当前拓扑序的位置（注意加边）。然后当k不够的时候，肯定需要把度为0的那些点中最小的k个分配一个未连入度。然后当k=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>
#include<unordered_map>
#define xx first
#define yy second
#define LL unsigned long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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 = 200000;

vector <int> v[maxn];
int in[maxn];

priority_queue<int> q, q2;
vector<pair<int, int> > ans;

int main ()
{
    freopen("graph.in", "r", stdin);
    freopen("graph.out", "w", stdout);
    int n, m, k;
    while(scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        CLR(in, 0);
        for(int i = 0; i <= n; i ++)
        {
            v[i].clear();
        }
        ans.clear();
        for(int i = 0; i < m; i ++)
        {
            int a, b;
            scanf("%d%d", &a, &b);
            in[b] ++;
            v[a].push_back(b);
        }
        while(!q.empty()) q.pop();
        for(int i = 1; i <= n; i ++)
        {
            if(in[i] == 0) q.push(i);
        }
        while(!q2.empty()) q2.pop();
        int pre = 0;
        while(true)
        {
            if(k == 0)
            {
                while(q.empty())
                {
                    if(q2.empty()) break;
                    int now = q2.top();
                    q2.pop();
                    ans.push_back(MP(pre, now));
                    pre = now;
                    for(int i = 0; i < v[now].size(); i ++)
                    {
                        int to = v[now][i];
                        if(-- in[to] == 0)
                        {
                            q.push(- to);
                        }
                    }
                }
                if(q.empty()) break;
                while(!q.empty())
                {
                    int now = -q.top(); q.pop();
                    pre = now;
                    for(int i = 0; i < v[now].size(); i ++)
                    {
                        int to = v[now][i];
                        if(-- in[to] == 0)
                        {
                            q.push(- to);
                        }
                    }
                }
                continue;
            }
            while(q.empty())
            {
                if(q2.empty()) break;
                int now = q2.top();
                q2.pop();
                ans.push_back(MP(pre, now));
                pre = now;
                for(int i = 0; i < v[now].size(); i ++)
                {
                    int to = v[now][i];
                    if(-- in[to] == 0)
                    {
                        q.push(to);
                    }
                }
            }
            if(q.empty()) break;
            if(!q2.empty() && q.top() < q2.top())
            {
                if(k <= q.size())
                {
                    vector<int> tmp;
                    while(!q.empty()) tmp.push_back(q.top()), q.pop();
                    sort(tmp.begin(), tmp.end());
                    for(int i = 0; i < k; i ++)
                    {
                        q2.push(tmp[i]);
                    }
                    for(int i = k; i < tmp.size(); i ++)
                    {
                        q.push(-tmp[i]);
                    }
                    k = 0;
                    continue;
                }
                int now = q2.top();
                q2.pop();
                ans.push_back(MP(pre, now));
                pre = now;
                k -= q.size();
                while(!q.empty())
                {
                    q2.push(q.top());
                    q.pop();
                }
                for(int i = 0; i < v[now].size(); i ++)
                {
                    int to = v[now][i];
                    if(-- in[to] == 0)
                    {
                        q.push(to);
                    }
                }
                continue;
            }
            if(k <= q.size() - 1)
            {
                vector<int> tmp;
                while(!q.empty()) tmp.push_back(q.top()), q.pop();
                sort(tmp.begin(), tmp.end());
                for(int i = 0; i < k; i ++)
                {
                    q2.push(tmp[i]);
                }
                for(int i = k; i < tmp.size(); i ++)
                {
                    q.push(-tmp[i]);
                }
                k = 0;
                continue;
            }
            k -= q.size() - 1;
            int now = q.top();
            q.pop();
            pre = now;
            while(!q.empty())
            {
                int tmp = q.top();
                q.pop();
                q2.push(tmp);
            }
            for(int i = 0; i < v[now].size(); i ++)
            {
                int to = v[now][i];
                if(-- in[to] == 0)
                {
                    q.push(to);
                }
            }
        }
        for(int i = 0; i < ans.size(); i ++)
        {
            v[ans[i].xx].push_back(ans[i].yy);
        }
        while(!q.empty()) q.pop();
        CLR(in, 0);
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 0; j < v[i].size(); j ++)
            {
                int a = i, b = v[i][j];
                in[b] ++;
            }
        }
        for(int i = 1; i <= n; i ++)
        {
            if(in[i] == 0) q.push(-i);
        }
        vector<int> out;
        while(!q.empty())
        {
            int now = q.top();
            now = -now;
            out.push_back(now);
            q.pop();
            for(int i = 0; i < v[now].size(); i ++)
            {
                int to = v[now][i];
                if(-- in[to] == 0)
                {
                    q.push(-to);
                }
            }
        }
        for(int i = 0; i < out.size(); i ++)
        {
            printf("%d ", out[i]);
        }puts("");
        printf("%d\n", ans.size());
        for(int i = 0; i < ans.size(); i ++)
        {
            printf("%d %d\n", ans[i].xx, ans[i].yy);
        }
    }
    return 0;
}
/**
4 1 1
3 4
*/

H- Hash Code Hacker

水题。题目给了4个相等的，所以随便组合1000个出来就好了。

//#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;

vector<string> vec;

string st[3] = {"edHs", "fEHs", "edIT"};

void dfs(int i, string tmp)
{
    if(i == 7)
    {
        vec.push_back(tmp);
        return ;
    }
    for(int j = 0; j < 3; j ++)
        dfs(i + 1, tmp + st[j]);
}

void init()
{
    vec.clear();
    dfs(0, "");
}

int main()
{
    freopen("hash.in","r",stdin);
    freopen("hash.out","w",stdout);
    init();
//    printf("%d --\n", vec.size());
    int k;
    while(scanf("%d", &k) != EOF)
    {
        for(int i = 0; i < k; i ++)
            cout << vec[i] << endl;
    }
    return 0;
}

J- Journey to the "The World's Start"

二分花费。然后验证答案。验证的时候用线段树加速一下就好了。

//#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 xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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 = 100100;

int mn[maxn << 2];

void up(int rt)
{
    mn[rt] = min(mn[rt << 1], mn[rt << 1 | 1]);
}

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

void update(int p, int v, int l, int r, int rt)
{
    if(l == r)
    {
        mn[rt] = v;
        return ;
    }
    int m = (l + r) >> 1;
    if(p <= m) update(p, v, lson);
    else update(p, v, rson);
    up(rt);
}

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

int p[maxn], d[maxn];
int n, t;

bool check(int pp)
{
    int r = 0;
    for(int i = 1; i < n; i ++)
    {
        if(p[i] <= pp) r = i;
    }
    if(r == 0) return false;
    build(1, n, 1);
    update(1, 0, 1, n, 1);
    for(int i = 2; i <= n; i ++)
    {
        int v = query(max(1, i - r), i - 1, 1, n, 1);
        update(i, v + d[i], 1, n, 1);
    }
    return query(n, n, 1, n, 1) <= t;
}

void solve()
{
    int l = 1, r = p[n - 1];
    while(l <= r)
    {
        int mid = (l + r) >> 1;
        if(check(mid)) r = mid - 1;
        else l = mid + 1;
    }
    printf("%d\n", l);
}

int main()
{
    freopen("journey.in", "r", stdin);
    freopen("journey.out", "w", stdout);
    while(scanf("%d%d", &n, &t) != EOF)
    {
        t -= n - 1;
        for(int i = 1; i < n; i ++)
            scanf("%d", &p[i]);
        for(int i = 2; i < n; i ++)
            scanf("%d", &d[i]);
        d[n] = 0;
        solve();
    }
    return 0;
}

L- Lucky Chances

水题。

//#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<time.h>
#include<map>
#define xx first
#define yy second
#define LL long long
#define MP make_pair
#define INF 0x3f3f3f3f
#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;

int s[1000][1000];
int main() {
    freopen("lucky.in", "r", stdin);
    freopen("lucky.out", "w", stdout);
    int n, m;
    while(cin >> n >> m) {
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < m; j ++) {
                scanf("%d", &s[i][j]);
            }
        }
        int ans = 0;
        for(int i = 0; i < n; i ++) {
            for(int j = 0; j < m; j ++) {
                int a = i - 1;
                bool ok = true;
                while(a >= 0) {
                    if(s[a][j] >= s[i][j]) ok = false;
                    a --;
                }
                if(ok) ans ++;

                a = i + 1;
                ok = true;
                while(a < n) {
                    if(s[a][j] >= s[i][j]) ok = false;
                    a ++;
                }
                if(ok) ans ++;

                a = j - 1;
                ok = true;
                while(a >= 0) {
                    if(s[i][a] >= s[i][j]) ok = false;
                    a --;
                }
                if(ok) ans ++;

                a = j + 1;
                ok = true;
                while(a < m) {
                    if(s[i][a] >= s[i][j]) ok = false;
                    a ++;
                }
                if(ok) ans ++;
            }
        }
        cout << ans << endl;
    }
    return 0;
}



ok_again
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【训练记录】2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest
执子之手,与子偕老
03-27 238
trac 补题 I题 给出m个(ai,bi,ci)，要求bi的排名在ai和ci之间 保证一定有合法的排名顺序符合要求 要求构造一个排名顺序 使得至少满足m / 2个三元组的关系 n,m<=1e5 题解 感谢wxh大佬 我们先求一个类似拓扑序的东西，要求bi不能同时出现在ai和ci的前面。（因为合法，所以有解） 按拓扑序倒着做，每个三元组在最后一个元素处考虑。那么最后一个元素要么是ai，...
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
【标题】"2015-2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International...
2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest（夏季组队赛第三场）
weixin_50909982的博客
08-06 258
A - Alex Origami Squares 题意：用给定一个长度和宽度组成的一个长方形纸，裁减出三个边长相等的正方形。 求这个正方形可能的最大边长。 思路：我们拿最一般的长方形纸（ 假设 m>nm>nm>n），一个边 mmm 从无穷递减，一个边 nnn 从0 增大，当n=mn=mn=m 时分析结束，因为nnn和mmm是对称的问题，所以我们假设当前长的边为 mmm 小的边为 nnn 即可。 当 m>=3⋅n时m>=3·n时m>=3⋅n时，显然以左边 n=rn=rn
2014-2015 ACM-ICPC, NEERC, Northern Subregional Contest I-Instruction(模拟)
yo_bc的博客
10-07 467
Ingrid is a head of a big railway station and, among other duties, is responsible for routing trains to the right platforms. The station has one entrance, and there are many switches that direct trains to other switches and platforms. Each switch has one i
Joy of Flight 2014-2015 ACM-ICPC, NEERC, Northern Subregional Contest
GameRoad
10-06 384
题意： 给出风速，最大速度，起点终点，询问是否能到达终点，以及没秒所在位置。 思路： 风速的矢量分离出来，求对于位移的影响，作用在dx dy上，求平均X的速度和Y的速度 #include #include #include #include #include #include #include using namespace std; typedef long long ll; dou
2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest 训练报告
weixin_33753845的博客
05-07 133
题目链接：http://codeforces.com/gym/100801 训练情况：AC8题，竟然读错了一道题，wa了挺多发。 说明：AC的代码中加了文件读入。 Problem A. Alex Origami Squares 题意：给你一个h*w的矩形，让你分成三个正方形，输出正方形的最大边长。 分析：直接在分成2*2份 3*1份 1*3份，取max就可以了 AC代码： #...
ACM-ICPC-制备：ACM-ICPC制备指南
02-02
在计算机科学领域，ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM-ICPC）是一项备受瞩目的赛事，它挑战参赛者的编程技能、算法理解和团队协作能力。对于希望在ACM-ICPC中...
个人ACM-ICPC模板acm-icpc-master.zip
最新发布
02-05
标题中的“个人ACM-ICPC模板acm-icpc-master.zip”指的是一个与ACM国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的个人开发的模板项目。这个压缩包很可能是参赛者或者教练为了...
ACM-CheatSheet：ACM-ICPC模板
02-03
ACM-ICPC备忘单 ACM-ICPC模板特征维护模板代码，自动生成PDF， 代码高亮，代码中渲染数学公式可直接插入tex文件仅包含一个文件的目录，会引入文件直接作为一个章节已有模板仅作为参考用法模板代码遵循/src目录下的...
两两认识leetcode-ACM-ICPC:ACM-ICPC
06-30
ACM-ICPC准备 该程序已开发用于学习用于竞争性编程的算法，但可用于： 竞技编程 面试练习 提高算法思维 为大学课堂练习 乐趣 课程要求： 至少精通一门编程语言。 （您必须能够有效地使用该语言。 ） 你必须熟悉一些...
2015-2016ACM-ICPC NEER northern-subregional-contest E Easy Arithmetic 思维、模拟
喵头鹰的博客
07-30 503
题目描述：Eva is a third-grade elementary school student. She has just learned how to perform addition and subtraction of arbitrary-precision integers. Her homework is to evaluate some expressions. It is b
I - Instruction 2014-2015 ACM-ICPC, NEERC, Northern Subregional Contest
GameRoad
10-06 482
题意： 给出每个火车的入境时间，现在有如干个开关，以及每个火车需要达到的处境口编号，询问开关的切换时间，以及切换编号 思路： 对于每个火车，前面的火车与后面的火车永远不会相撞（只要让前面的火车一直运动下去）。因此每个节点当前只需要处理当前的火车即可 记录节点的状态 （0，1 表示左侧还是右侧开关状态） #include #include #include #include #includ
2017-2018 ACM-ICPC, NEERC, Northern Subregional Contest训练赛
yeleng的博客
09-30 459
两个紫名大佬带我躺。。。 题目 这里只写我看了题意的题： Problem C. Consonant Fencity： 英语渣表示看不懂题目，题意是这样给一个全小写字符串，期中有A和B类字符，求B类字符相邻一个为大写一个为小写的个数最多的串，也就是自己构造一些字符全部替换成大写，一些字符替换成全部为小写。 1、那么只有19个字符，枚举每个字符是否为大写还是小2^19 2、然后把两个小写字...
Gym - 100792A Anagrams （2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest)
床前明月光
09-22 546
手推规律 题意是 ： 在 B 进制下 找到所有的 K， 满足所有 K 的十进制下的整数倍的一个数 M ，转化成 B 进制后对应的数位重新排列的数转化成十进制还是 K 的整数倍 推出来的规律 就是 给定的 n 减去 1 的所有因子 #include #include #include #include #include #include #include #include
【2015-2016 ACM-ICPC, NEERC, Northern Subregional Contest B】【构造】Black and White 构造棋盘使得两种棋子联通块数恰为x与y
snowy_smile的博客
11-15 835
#include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; #define MS(x,y) memset(x,y,sizeof(x)) #define MC(x,y) memcpy(x
2016-2017 ACM-ICPC, NEERC, Central Subregional Contest【9/11】
mengxiang000000
10-01 668
A.Fried Fish 给出N条鱼，我们同时可以去做K条鱼，每条鱼需要2s做的时间，问将所有鱼都做好需要多长时间、 贪心就行，注意n B.Hanoi tower 找找规律就行了。 n/=3 Ans=pow（2，2*n+1）+（n%2==1?(-2):(-1)）； n=（n+1）/2； Ans2=pow（2，2*n+1）； OUTPUT=Ans+Ans2； 问题需要大数，Jav
2015-2016 ACM-ICPC, NEERC, Moscow Subregional Contest I题：Illegal or Not? [暴力题]
Asuna_acmer
10-24 747
给出N个线段，问你1到1826范围内，是否有连续的一段（长度固定为180），含有其余线段的部分总长超过90（同一块不重复Count）
2016-2017 ACM-ICPC, NEERC, Central Subregional Contest D
weixin_30871293的博客
07-05 105
Weather Station 题意：有N E S W NE SE SW NW 一共8个方向，给一个只包含 N E S W的字符串，求它能表示多少种不同方向的组合 思路：求字符串里一共有多少NE SE SW NW 这些既可以表示为NE... 也可以表示为N E... AC代码： #include "iostream" #include "string.h" #include "st...
2016-2017 ACM-ICPC, NEERC, Southern Subregional Contest H. Delete Them
weixin_34414196的博客
10-23 136
H. Delete Them time limit per test 2 seconds memory limit per test 512 megabytes input standard input output standard output Polycarp is a beginner programmer. He is studying ho...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值