Codeforces Round #571 (Div. 2)

A. Vus the Cossack and a Contest

籤。

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

int main() {
    int n, m, k;
    while (scanf("%d%d%d", &n, &m, &k) != EOF) {
        if (min(m, k) >= n) {
            puts("YES");
        } else {
            puts("NO");
        }
    }
    return 0;
}

C. Vus the Cossack and Strings

題意：
給出\(a, b\)兩個01串，\(|a| \geq |b|\)，詢問\(a\)中全部長度等於\(|b|\)的子串和\(b\)異或以後\(1\)的個數爲偶數的子串有多少個。

思路：
最天然的想法是枚舉\(a\)中全部長度爲\(|b|\)的子串。
其實最終咱們不須要關心\(1\)的個數有多少個，只須要關心奇偶性。
那麼咱們暴力弄出第一個子串異或以後的\(1\)的個數模2的值。
再考慮，指針往右移動一位，會發生什麼？
好比說
011000
00110

01100 -> 11000
會發生什麼？

咱們注意到，這個過程至關於將\(b\)串往右移動一位，
那麼對於\(a\)串來講，是去掉第一個字符和增長最後一個字符，中間的字符不變。
那麼對於中間的字符來講，它對應的\(b\)中的值是前一位以前對應的\(b\)中的值，那麼你要繼承它的狀態。
那麼若是你和前一位是相同的，那麼前一位以前對應的\(b\)中的值移過來的時候不會改變答案的奇偶性。
不然會改變。
前綴異或一下便可。

代碼：

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

#define N 1000010
char s[N], t[N];

int main() {
    while (scanf("%s%s", s + 1, t + 1) != EOF) {
        int lens = strlen(s + 1), lent = strlen(t + 1);
        int res = 0, Xor = 0, tot = 0;   
        for (int i = 1; i <= lent; ++i) { 
            if (s[i] != t[i]) {
                tot ^= 1;  
            }
            if (i > 1 && s[i] != s[i - 1]) Xor ^= 1; 
        }
        res += tot ^ 1;
        for (int i = lent + 1; i <= lens; ++i) {
            if (s[i] != s[i - 1]) Xor ^= 1; 
            int pre = i - lent;
            if (pre > 1 && s[pre] != s[pre - 1]) Xor ^= 1;
            tot ^= Xor;
            res += tot ^ 1; 
        }
        printf("%d\n", res);
    }
    return 0;
}

D. Vus the Cossack and Numbers

題意：
給出\(n\)個實數，他們的和爲\(0\)，如今要求將每一個實數上取整或者下去整，使得它們的和仍是爲\(0\)。

思路：
先將全部數都下去整，而後看差多少，就補回來。

處理實數的時候用字符串，忘記考慮0和-0的問題FST了。

代碼：

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

#define ll long long
#define N 100010
int n;
char s[110];
int a[N], b[N], c[N];

int main() {
    while (scanf("%d", &n) != EOF) {
        int can = 0;
        ll sum = 0;
        for (int i = 1; i <= n; ++i) {
            scanf("%s", s + 1);
            a[i] = 0, b[i] = 0;
            int j = 1, len = strlen(s + 1);
            int f = 1;
            if (s[1] == '-') ++j, f = -1;   
            for (; j <= len && s[j] != '.'; ++j) {
                a[i] = a[i] * 10 + s[j] - '0';
            }
            for (++j; j <= len; ++j) {
                b[i] = b[i] * 10 + s[j] - '0';
            }
            a[i] *= f;
            if (b[i] != 0) {
                ++can;
                if (f == -1) {
                    --a[i];
                }
            }
            sum += a[i];
        }
        sum = abs(sum);
        //assert(sum <= can);   
        for (int i = 1; i <= n; ++i) {
            if (sum > 0 && b[i] != 0) {
                ++a[i];
                --sum;
            }
        }
        for (int i = 1; i <= n; ++i) {
            printf("%d\n", a[i]);
        }   
    }
    return 0;
}

F. Vus the Cossack and a Graph

題意：
有一張\(n\)個點，\(m\)條邊的圖。要求最多保留\(\left \lceil \frac{n + m}{2} \right \rceil\)條邊，使得每一個點的新的度數\(f_i \geq \left \lceil \frac{d_i}{2} \right \rceil\)，其中\(d_i\)爲原來的度數。

思路：
顯然，能夠理解爲刪去\(m - \left \lceil \frac{n + m}{2} \right\rceil\)條邊，由於要保留儘可能多的邊沒有壞處，
那麼咱們能夠考慮每一個點最多刪去的度數爲\(D_i = d_i - \left \lceil \frac{d_i}{2} \right \rceil\)，那麼咱們優先刪去\(D_i\)小的點鄰接的\(D_i\)大的點的邊。
由於這樣貪心可以保證\(D_i\)小的點鄰接的邊可以被優先刪除，不然這些\(D_i\)小的點鄰接的邊對應的那個點可能由於被刪除了其它邊，致使可用度數不夠而這些邊不能被刪除。
而對於可用度數大的點來講，刪去哪些邊的影響不大。
而咱們找到了一個\(D_i\)最小的點，那麼要怎麼去選擇它鄰接的邊去刪除呢？
要選擇鄰接的邊對應的點的\(D_i\)大的刪除。
由於若是選擇\(D_i\)小的，那可能刪完它們的\(D_i\)都變爲0，不能刪了。
可是可能存在這兩個點都鄰接一個\(D_i\)大的點，這樣就能夠刪兩條邊，不然只能刪一條邊。

代碼：

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

#define N 1000010
#define pii pair <int, int>
#define fi first
#define se second
int n, m;
int del[N];  
vector < vector <pii> > G; 
int d[N], a[N];
int e[N][2];  

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        memset(del, 0, sizeof del); 
        memset(d, 0, sizeof d);
        G.clear();
        G.resize(n + 1);
        int needdel = m - (n + m + 1) / 2; 
        for (int i = 1, u, v; i <= m; ++i) {
            scanf("%d%d", &e[i][0],  &e[i][1]);
            u = e[i][0], v = e[i][1];
            G[u].push_back(pii(v, i));
            G[v].push_back(pii(u, i));
            ++d[u]; ++d[v]; 
        }
        if (needdel <= 0) {
            printf("%d\n", m);
            for (int i = 1; i <= m; ++i) {
                printf("%d %d\n", e[i][0], e[i][1]);  
            }
            continue;
        }
        priority_queue <pii, vector <pii>, greater <pii> > pq; 
        for (int i = 1; i <= n; ++i) {
            d[i] = d[i] - (d[i] + 1) / 2;
            pq.push(pii(d[i], i));
        }
        int u, v;
        while (needdel > 0) {
            u = 0;
            while (!pq.empty()) {
                u = pq.top().se; pq.pop();
                if (d[u] <= 0) {
                    u = 0;
                    continue; 
                }
                else break;
            }
            if (u == 0) break;  
            sort(G[u].begin(), G[u].end(), [](pii x, pii y) {
                return d[x.fi] > d[y.fi];       
            }); 
            for (auto it : G[u]) {
                if (del[it.se]) continue;
                v = it.fi;
                if (d[v] <= 0) continue; 
                del[it.se] = 1;
                --d[u]; --needdel;
                --d[v];
                if (d[v] > 0) {
                    pq.push(pii(d[v], v));
                }
                if (d[u] <= 0 || needdel <= 0) break;  
            }
        }
        int sze = (n + m + 1) / 2;
        printf("%d\n", sze);
        int cnt = 0;
        for (int i = 1; i <= m; ++i) {
            if (del[i] == 0) {
                ++cnt;
                printf("%d %d\n", e[i][0], e[i][1]);
            }
        }
        assert(sze == cnt); 
    }
    return 0;
}