CodeForces Round #301 Div.2

今天唯一的成果就是把上次几个人一起开房打的那场cf补一下。

A. Combination Lock

此等水题看一眼样例加上那个配图我就明白题意了，可是手抽没有注释掉freopen，WA了一发。

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1000 + 10;

char s1[maxn], s2[maxn];

int main()
{
    int n; cin >> n;
    scanf("%s", s1);
    scanf("%s", s2);
    int ans = 0;
    for(int i = 0; i < n; i++)
    {
        int a = s1[i] - '0';
        int b = s2[i] - '0';
        if(a < b) swap(a, b);
        ans += min(a - b, 10 - a + b);
    }
    cout << ans << "
";

    return 0;
}

B. School Marks

这道题本身不难，因为所给的n是奇数。但有可能会想错细节或漏掉情况。

n个数排好序，中间那个数一定是中位数，而且左右两边各n / 2个数。

所以我们看已知的k个数中比y小的数有多少个，如果大于n/2个，那么中位数一定小于y，无解。

如果k个数中不小于y的大于n / 2个，那么根据贪心，中位数已经在这些数里面了，所以剩下的n-k个数补成1就好了。

其次可以把中位数y插到这里面去，而且能算出中位数左边要补多少个1，右边要补多少个y。

注意在上面所有的情况中还要判断总数是否不超过x。

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1000 + 10;
int a[maxn];

int main()
{
    //freopen("in.txt", "r", stdin);

    int n, k, p, x, y;
    cin >> n >> k >> p >> x >> y;
    for(int i = 0; i < k; i++) scanf("%d", &a[i]);
    sort(a, a + k);
    int t = lower_bound(a, a + k, y) - a;
    if(t > n / 2) { puts("-1"); return 0; }

    int s = 0;
    for(int i = 0; i < k; i++) s += a[i];
    if(k - t > n / 2)
    {
        int p = n - k;
        if(s + p > x) { puts("-1"); return 0; }
        printf("1");
        for(int i = 1; i < p; i++) printf(" 1");
        puts(""); return 0;
    }

    int l = n / 2 - t;
    int r = n / 2 - k + t;
    if(s + l + (r + 1) * y > x) { puts("-1"); return 0; }
    bool print = false;
    for(int i = 0; i < l; i++) { if(print) printf(" "); print = true; printf("1"); }
    for(int i = 0; i <= r; i++) { if(print) printf(" "); print = true; printf("%d", y); }

    return 0;
}

C. Ice Cave (BFS)

总体来说这场CF难度偏易，虽然比赛的时候逗比地爆一了。但是下来的时候，手写一遍，没有编译错误交上去还过了，比赛要是这状态，啧啧

这道题一开始没有理解题意，其实就是地图上的'.'走过一遍就变成'X'，而且'X'就不能再走了，终点除外。

问从能否起点走到终点，而且把终点变成'X'

把题意理解了，直接BFS就好啦，而且vis标记都不用，直接修改地图就好了。

#include <bits/stdc++.h>
using namespace std;

const int maxn = 500 + 10;

char s[maxn][maxn];
int n, m;

struct Node
{
    int x, y;
    Node(int x = 0, int y = 0):x(x), y(y) {}
}st, ed;

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

inline bool in(int x, int y) { return x > 0 && x <= n && y > 0 && y <= m; }

bool BFS()
{
    queue<Node> Q;
    Q.push(st);
    while(!Q.empty())
    {
        Node now = Q.front(); Q.pop();
        for(int i = 0; i < 4; i++)
        {
            int x = now.x + dx[i];
            int y = now.y + dy[i];
            if(!in(x, y)) continue;
            if(s[x][y] == 'X') { if(x == ed.x && y == ed.y) return true; continue; }
            s[x][y] = 'X';
            Q.push(Node(x, y));
        }
    }
    return false;
}

int main()
{
    //freopen("in.txt", "r", stdin);

    cin >> n >> m;
    for(int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
    scanf("%d%d%d%d", &st.x, &st.y, &ed.x, &ed.y);
    printf("%s
", BFS() ? "YES" : "NO");

    return 0;
}

D. Bad Luck Island (概率 DP)

题解写得很清楚，递推或者DFS都行。

#include <cstdio>
#include <iostream>
using namespace std;

const int maxn = 100 + 5;
double d[maxn][maxn][maxn];

int main()
{
    int a, b, c;
    cin >> a >> b >> c;
    d[a][b][c] = 1.0;
    for(int i = a; i >= 0; i--)
        for(int j = b; j >= 0; j--)
            for(int k = c; k >= 0; k--)
            {
                if(!i && !j) continue;
                if(!i && !k) continue;
                if(!j && !k) continue;
                double cur = d[i][j][k];
                double tot = i*j + i*k + j*k;
                if(i) d[i-1][j][k] += cur * (double)(i*k) / tot;
                if(j) d[i][j-1][k] += cur * (double)(i*j) / tot;
                if(k) d[i][j][k-1] += cur * (double)(j*k) / tot;
            }

    double aa = 0, bb = 0, cc = 0;
    for(int i = 1; i <= a; i++) aa += d[i][0][0];
    for(int i = 1; i <= b; i++) bb += d[0][i][0];
    for(int i = 1; i <= c; i++) cc += d[0][0][i];

    printf("%.12f %.12f %.12f
", aa, bb, cc);

    return 0;
}

E. Infinite Inversions (树状数组 离散化)

可以把所求分成两个部分来计：

把这2n个数进行一次离散化，比如排序去重以后变成m个数。

那么经过m次操作，这m个数相较于初始状态是一个这m个数的排列。所以可以用树状数组计算一个这m个数之间的逆序数，注意这里不涉及位置没有变化的那些数。

这样我们便完成了第一部分的计数。

剩下的一部分是这m个数与其他位置未发生变化的逆序数。

预处理一下m个数中第i个数与第1个数之间有多少个数未发生位置改动sum[i]。

比如这m个数经过n次两两交换以后，第i个数的大小为rank[i]，那么未发生位置改动的数与第i个数构成的逆序对有abs(sum[i] - sum[rank[i]])

举个栗子：

比如2 7互换，序列由

1 2 3 4 5 6 7 8 变成 1 7 3 4 5 6 2 8

2和7之间有4个数没有变(即3 4 5 6)，对于2 7而言，7到2前面去了这是一个逆序对，也就是我们计数的第一部分。

对于2来说，2在7的位置，而且3 4 5 6都与2构成一个逆序对，因此贡献了4个逆序对；

对于7同样，7在2的位置，3 4 5 6在7的后面也贡献了4个逆序对。

所以最终答案为9

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

typedef long long LL;
const int maxn = 200000 + 10;

int a[maxn], b[maxn], x[maxn], r[maxn];
LL sum[maxn], s[maxn];
int n, m;

inline int lowbit(int x) { return x&(-x); }

void add(int x, LL d)
{ while(x <= m) { s[x] += d; x += lowbit(x); } }

LL query(int x)
{
    LL ans = 0;
    while(x) { ans += s[x]; x -= lowbit(x); }
    return ans;
}

int main()
{
    //freopen("in.txt", "r", stdin);

    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d", &a[i], &b[i]);
        x[i*2-1] = a[i]; x[i*2] = b[i];
    }
    sort(x + 1, x + 1 + n*2);
    m = unique(x + 1, x + 1 + n*2) - x - 1;
    for(int i = 1; i <= m; i++)
    {
        sum[i] = sum[i - 1] + x[i] - x[i - 1] - 1;
        r[i] = i;
    }
    for(int i = 1; i <= n; i++)
    {
        int ta = lower_bound(x + 1, x + 1 + m, a[i]) - x;
        int tb = lower_bound(x + 1, x + 1 + m, b[i]) - x;
        swap(r[ta], r[tb]);
    }

    LL inv = 0;
    for(int i = m; i > 0; i--)
    {
        inv += query(r[i]);
        add(r[i], 1);
        inv += abs(sum[i] - sum[r[i]]);
    }

    cout << inv << endl;

    return 0;
}