2016.1.18 acm算法讨论群群赛

套题链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=104142#overview

难度类型：前两题较基础，后两题dp要一定火候，中间的搜索需要姿势好，会卡时间。

A

题解

类型：模拟，排序，贪心

目标是尽量多地打折，因此排序从后往前分连续三元组，取其中最小的累加。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
LL powmod(LL a,LL b, LL MOD) {LL res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
// head
const int N = 2E4+5;

int a[N];
int main()
{
    int t, n;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        int ans = 0;
        for (int i = 0; i < n; i++) {
            scanf("%d", a+i);
        }
        sort(a, a+n);
        for (int i = n-1; i > 1; i -= 3) {
            ans += a[i-2];
        }
        printf("%d\n", ans);
    }
    return 0;
}

B

题解

类型：数论

找到拥有最大素因子的数，做个预处理就行了，欧拉筛可以直接做出来。

素数的最大因子是本身，合数的话由于筛的p[j]是最小的素因子，因而直接去i的最大素因子即可。

这是赛后改的，比较普通的想法是筛出素数再扫一遍，从小到大每个素数对其倍数赋值自己。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
LL powmod(LL a,LL b, LL MOD) {LL res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
// head
const int N = 20000+5;

bool vis[N];
int p[N];
int tot = 0;

int gfac[N];
void getPrime(int n) {
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) p[++tot] = i, gfac[i] = i;
        for (int j = 1; j<=tot && i*p[j]<=n; j++) {
            vis[i*p[j]] = true;
            gfac[i*p[j]] = gfac[i];
            if (i%p[j]==0) break;
        }
    }
}

int main()
{
    getPrime(20000);

    int n, x;
    while (scanf("%d", &n) == 1) {
        int ans = 0, mx = -1;
        for (int i = 0; i < n; i++) {
            scanf("%d", &x);
            if (gfac[x] > mx) {
                mx = gfac[x];
                ans = x;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

C

题解

类型：bfs，卡常数

草上烧两把火，问最少多久把所有草烧光。

枚举两个起点，然后bfs，但是常数卡得比较好，需要一些优化或者好姿势。

基本的做法是把草塞到数组里再去枚举。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
LL powmod(LL a,LL b, LL MOD) {LL res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
// head
const int N = 15;
const int INF = 0x3f3f3f3f;

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

int t, n, m, cas = 1;

PII mov(PII &cur, int dir) {
    return mp(cur.fi+dx[dir], cur.se+dy[dir]);
}

bool isok(PII &cur) {
    return cur.fi > 0 && cur.fi <= n && cur.se > 0 && cur.se <= m;
}

char s[N][N];
int a[N][N];

int solve(int x1, int y1, int x2, int y2) {
    memset(a, INF, sizeof a);
    queue<PII> q;
    q.push(mp(x1, y1));
    q.push(mp(x2, y2));
    a[x1][y1] = a[x2][y2] = 0;

    int ans = 0;
    while (!q.empty()) {
        PII cur = q.front();
        q.pop();
        ans = max(ans, a[cur.fi][cur.se]);

        for (int dir = 0; dir < 4; dir++) {
            PII nxt = mp(cur.fi+dx[dir], cur.se+dy[dir]);
            if (!isok(nxt) || s[nxt.fi][nxt.se] == '.' || a[nxt.fi][nxt.se] != INF) continue;
            a[nxt.fi][nxt.se] = a[cur.fi][cur.se]+1;
            q.push(nxt);
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (s[i][j] == '#' && a[i][j] == INF) return INF;
        }
    }
    return ans;
}

PII cao[105];
int main()
{
    scanf("%d", &t);
    while (t--) {
        int caocnt = 0;
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++) {
            scanf("%s", s[i]+1);
            for (int j = 1; j <= m; j++) {
                if (s[i][j] == '#') cao[caocnt++] = mp(i, j);
            }
        }

        int ans = INF;
        for (int i = 0; i < caocnt; i++) {
            for (int j = i; j < caocnt; j++) {
                ans = min(ans, solve(cao[i].fi, cao[i].se, cao[j].fi, cao[j].se));
            }
        }
        printf("Case %d: %d\n", cas++, ans==INF ? -1 : ans);
    }
    return 0;
}

D

题解

类型：dp，数位dp

太久没写数位dp有点手生，A得有点慢了。

题目的限制可以转化为对于上下界的变化，需要一个看奇偶位数的量。

因而三维dp乱搞，开始稀里糊涂过了，写法很诡异，附在代码注释中。三维分别是位数，前一位的大小，还有位的奇偶性。

保存是否前面均为0，如果i==0&&zero 也就是下一位还是0，那就保持false，否则开始反转。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
LL powmod(LL a,LL b, LL MOD) {LL res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
// head
const int INF = 0x3f3f3f3f;
const int N = 15;

int dp[N][N][2];
int a[N];

int dfs(int pos, int pre, bool flag, bool e, bool zero) {
    if (pos == -1) return 1;
    if (!e && dp[pos][pre][flag] != INF) return dp[pos][pre][flag];

    int ans = 0;
    int lim = e ? a[pos] : 9;
    int lb = flag ? pre : 0;
    int ub = flag ? lim : min(lim, pre);
    for (int i = lb; i <= ub; i++) {
        if (zero&&i==0) {
            ans += dfs(pos-1, 9, false, i==a[pos]&&e, true);
        } else {
            ans += dfs(pos-1, i, !flag, i==a[pos]&&e, false);
        }
    }
//  for (int i = lb; i <= ub; i++) {
//    // 诡异写法，但是可以发现实际执行和上头的一致，正好哦
//      ans += dfs(pos-1, i, zero?true:!flag, i==a[pos]&&e, zero&&i==0);
//  }

    if (!e) dp[pos][pre][flag] = ans;
    return ans;
}

int solve(int x) {
    int cnt = 0;
    while (x) {
        a[cnt++] = x%10;
        x /= 10;
    }
    return dfs(cnt-1, 9, false, true, true);
}

int main() {
    memset(dp, INF, sizeof dp);
    int t, l, r;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &l, &r);
        printf("%d\n", solve(r)-solve(l-1));
    }
    return 0;
}

E

题解

类型：dp

要用正三角形去组合出最大的三角形，可以看出面积就是边长平方。

转移共有三个方向，也就是三个角的方向，需要通过(i+j)的奇偶性看三角形向上还是向下。

转移方式，从上到下的话，那下方一块必须是白色（蓝色），然后根据左下，右下（俩绿色）的该方向长度的最小值+1得到当前最大。

可以手写出位移的数组，然后去处理，这样比较方便，向上和向下其实就是方向相反，处理一个，然后方向全部反转即可。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <set>
#include <map>

#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> PII;
LL powmod(LL a,LL b, LL MOD) {LL res=1;a%=MOD;for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
// head
const int N = 100+5;

int dnx[15] = {0, 1, 0, 1, -1, -1, 0, -1, 0, -1, 1, 1};
int dny[15] = {2, 1, -2, -1, -1, 1, -2, -1, 2, 1, 1, -1};

int dcx[15] = {0, 0, -1, 0, 0, 1};
int dcy[15] = {1, -1, 0, -1, 1, 0};

char s[N][2*N];
int dp[N][2*N][6];

int dfs(int x, int y, int dir) {
    if (dp[x][y][dir] != -1) return dp[x][y][dir];
    if (s[x][y] != '-') return dp[x][y][dir] = 0;

    int cx = x+dcx[dir], cy = y+dcy[dir];
    if (s[cx][cy] != '-') return dp[x][y][dir] = 1;

    int ans = 1e5;
    for (int i = 0; i < 2; i++) {
        int pos = 2*dir+i;
        int nx = x+dnx[pos], ny = y+dny[pos];
        ans = min(ans, dfs(nx, ny, dir));
    }
    return dp[x][y][dir] = ans+1;
}

int main()
{
    int n, cas = 1;
    while (scanf("%d", &n) == 1 && n) {
        memset(s, 0, sizeof s);
        memset(dp, -1, sizeof dp);
        for (int i = 1; i <= n; i++) {
            scanf("%s", s[i]+i);
        }

        int ans = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = i; s[i][j] != '\0'; j++) {
                for (int dir = 0; dir < 3; dir++) {
                    ans = max(ans, dfs(i, j, ((i+j)&1) ? dir+3 : dir));
                }
            }
        }
        printf("Triangle #%d\nThe largest triangle area is %d.\n\n", cas++, ans*ans);
    }
    return 0;
}