Codeforces Round #511 (Div. 2)

A - Little C Loves 3 I

题意：把一个>=3的数分成3个均不是3的倍数的数。

题解：
当n%30，分为1,1,1。
当n%31，分为1,1,2。
当n%3==2，分为1,2,2。

void test_case() {
    int n;
    scanf("%d", &n);
    if(n % 3 == 0)
        printf("1 1 %d
", n - 2);
    if(n % 3 == 1)
        printf("1 2 %d
", n - 3);
    if(n % 3 == 2)
        printf("2 2 %d
", n - 4);
}

B - Cover Points

题意：一个两边都在坐标轴上的等腰三角形，覆盖所有给的第一象限点。求短边长。

题解：所以一定是腰在坐标轴上。比A还水。

void test_case() {
    int n;
    scanf("%d", &n);
    int ans = 0;
    while(n--) {
        int x, y;
        scanf("%d%d", &x, &y);
        ans = max(ans, x + y);
    }
    printf("%d
", ans);
}

C - Enlarge GCD

题意：给n个数，那么他们有gcd，去掉最多n-1个数使得他们的gcd变大。求去掉最少的数。

题解：首先如果所有数都相等，那么无解。否则一定有解：最多去掉只剩下最大的那个。gcd是没有影响的，可以直接除掉（注意gcd可以用0来初始化，0和x的gcd都等于x）。然后除去gcd之后每个数有他独特的几种因子，把不含这种因子的数都去掉就可以把这种因子释放出来。暴力sqrt分解会T掉，线性筛/埃筛预处理出每个数的最小质因子（甚至不需要预处理出他的幂，反正除一除也是log级别的）就把复杂度降低到质因子的最大个数（当一直除时，大概27左右）或者质因子的种类（当预处理出每个数含有的最小质因子的幂时，不超过8个），比sqrt的大概4000要快100倍。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
 
const int MAXN = 1e7 + 5e6;
int p[970704 + 5], ptop;
int pm[MAXN + 5], pk[MAXN + 5];
 
void sieve() {
    int n = MAXN;
    pm[1] = 1;
    pk[1] = 1;
    for(int i = 2; i <= n; i++) {
        if(!pm[i]) {
            p[++ptop] = i;
            pm[i] = i;
            pk[i] = i;
        }
        for(int j = 1; j <= ptop; j++) {
            int t = i * p[j];
            if(t > n)
                break;
            pm[t] = p[j];
            if(i % p[j]) {
                pk[t] = pk[p[j]];
            } else {
                pk[t] = pk[i] * p[j];
                break;
            }
        }
        //printf("i=%d pm=%d pk=%d
", i, pm[i], pk[i]);
    }
    //printf("ptop=%d
",ptop);
    /*for(int i=1;i<=ptop;++i)
        printf("%d:%d
",i,p[i]);*/
}
 
int a[300005];
int ans[MAXN + 5];
 
void test_case() {
    int n, cnt1 = 0;
    scanf("%d", &n);
    int gcd = 0;
    for(int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
        gcd = __gcd(gcd, a[i]);
    }
    for(int i = 1; i <= n; ++i) {
        a[i] /= gcd;
        while(a[i] > 1) {
            ans[pm[a[i]]]++;
            a[i] /= pk[a[i]];
        }
    }
    int minans = n;
    for(int i = 1; i <= MAXN; ++i)
        minans = min(minans, n - ans[i]);
    printf("%d
", minans == n ? -1 : minans);
}

D - Little C Loves 3 II

题意：给n*m的棋盘，每次放曼哈顿距离为3的一对棋子，求最多放多少个棋子。

题解：已知假如行是6的倍数或者列是6的倍数就直接可以放满。可以大胆猜测要模到6以内求解（但不能够同时模到6以内，比如2 8，这个假如区域赛遇到就要拜托队友手动打表找，然后和小数据比对了，毕竟大数据按常理是很容易放满的）。

余1的话，那就直接贪心放就可以了。

余2的情况，只有2*1,2*2,2*3,2*7是不能放满的。（放满可以构造证明，但是放不满怎么证明呢？）

余4的情况，注意到4*2和4*3可以放满，所以4*x当x>=2时都可以放满。

余3和余5的情况，多放几个发现是两个都是奇数的时候就是-1，否则可以放满，可能是因为>=3的都很好调整。

总之这道题出得很不好，正式比赛出了要被喷。