[Codeforces]Good Bye 2017

A - New Year and Counting Cards

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;


void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}

int a[256];

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(0), cin.tie(0);
    string s;
    cin >> s;
    int n = s.size();
    for (int i = 0; i < n; i++) a[s[i]]++;
    cout << (a['1'] + a['3'] + a['5'] + a['7'] + a['9'] + a['a'] + a['e'] + a['i'] + a['o'] + a['u']) << endl;
    return 0;
}

B - New Year and Buggy Bot

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;


void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}

string mp[100], s;
int d[4], op[200];
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(0), cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) cin >> mp[i];
    cin >> s;
    int l = s.size();
    for (int i = 0; i < l; i++) op[i] = s[i] - '0';
    int sx, sy;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (mp[i][j] == 'S') {
                sx = i;
                sy = j;
            }
        }
    }
    int ans = 0;
    bool f[4];
    for (d[0] = 0; d[0] < 4; d[0]++) {
        for (d[1] = 0; d[1] < 4; d[1]++) {
            for (d[2] = 0; d[2] < 4; d[2]++) {
                for (d[3] = 0; d[3] < 4; d[3]++) {
                    memset(f, false, sizeof(f));
                    f[d[0]] = true, f[d[1]] = true, f[d[2]] = true, f[d[3]] = true;
                    if (f[0] && f[1] && f[2] && f[3]) {
                        int x = sx, y = sy, j;
                        bool ok = false;
                        for (int i = 0; i < l; i++) {
                            j = d[op[i]];
                            x += dx[j], y += dy[j];
                            if (x < 0 || x >= n || y < 0 || y >= m) break;
                            if (mp[x][y] == '#') break;
                            if (mp[x][y] == 'E') {
                                ok = true;
                                break;
                            }
                        }
                        if (ok) ans++;
                    }
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

C - New Year and Curling

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;


void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}

class SAM {
private:
    int Last, sz;
    vector<int [26]> ch;
    vector<int> fa, maxlen;
public:
    void init() {
        sz = 1;
        ch.clear();
    }
    void add(int x) {
        int np = ++sz, p = Last;
        Last = np;
        memset(ch[np], 0, sizeof(ch[np]));
        maxlen[np] = maxlen[p] + 1;
        while (p && !ch[p][x]) ch[p][x] = np, p = fa[p];
        if (!p) fa[np] = 1;
        else {
            int q = ch[p][x];
            if (maxlen[p] + 1 == maxlen[q]) fa[np] = q;
            else {
                int nq = ++sz;
                memcpy(ch[nq], ch[q], sizeof(ch[q]));
                maxlen[nq] = maxlen[p] + 1;
                fa[nq] = fa[q];
                fa[q] = fa[np] = nq;
                while (p && ch[p][x] == q) ch[p][x] = nq, p = fa[p];
            }
        }
    }
};
double x[2000], y[2000];
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    //std::ios::sync_with_stdio(0), cin.tie(0);
    int n;
    double r, h;
    //cin >> n >> r;
    scanf("%d%lf", &n, &r);
    for (int i = 0; i < n; i++) {
        //cin >> x[i];
        scanf("%lf", &x[i]);
        y[i] = r;
        for (int j = 0; j < i; j++) {
            if (fabs(x[i] - x[j]) <= 2 * r) {
                h = sqrt(4 * r * r - (x[i] - x[j]) * (x[i] - x[j])) + y[j];
                if (y[i] < h) y[i] = h;
            }
        }
    }
    for (int i = 0; i < n; i++) printf("%.8lf ", y[i]); //cout << y[i] << ' ';
    return 0;
}

D - New Year and Arbitrary Arrangement

#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;

const int MOD = 1000 * 1000 * 1000 + 7;

ll pw(ll a, ll b = MOD - 2) {
    if (b == 0) {
        return 1;
    }

    ll v = pw(a, b / 2);
    v = (v * v) % MOD;

    if (b & 1) {
        v = (v * a) % MOD;
    }

    return v;
}

constexpr int MAXN = 1001;

ll f[MAXN][MAXN];

int main() {
#ifdef PAUNSVOKNO
    freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(false); cout.setf(ios::fixed); cout.precision(20); cout.tie(nullptr); cin.tie(nullptr);
    ll k, pa, pb;
    cin >> k >> pa >> pb;
    ll s = pw(pa + pb);
    pa = (pa * s) % MOD;
    pb = (pb * s) % MOD;

    ll ans = 0;

    f[1][0] = 1;

    ll last = (1 - pa + MOD) % MOD;
    last = pw(last, MOD - 2);
    last = (last - 1 + MOD) % MOD;

    for (int i = 1; i <= k; ++i) {
        for (int j = 0; j <= k; ++j) {
            if (i + j >= k) {
                ll val = j + i + last;
                ans = (ans + f[i][j] * val) % MOD;
            } else {
                f[i + 1][j] = (f[i + 1][j] + f[i][j] * pa) % MOD;
                f[i][j + i] = (f[i][j + i] + f[i][j] * pb) % MOD;
            }
        }
    }

    cout << ans << "
";
}

E - New Year and Entity Enumeration

#include<bits/stdc++.h>
#define ll long long
#define mod 1000000007
using namespace std;

ll m,n,c[1010][1010],f[1010],b[1010],x,ans=1;
map<ll,ll>mp;

int main(){
    for (cin>>m>>n;n--;)
        for (int i=0;i<m;++i)
            scanf("%1lld",&x), b[i]|=x<<n;
    for (int i=0;i<m;++i) ++mp[b[i]];
    for (int i=0;i<=m;++i)
        for (int j=0;j<=i;++j)
            c[i][j]= j? (c[i-1][j-1]+c[i-1][j])%mod: 1;
    f[0]=f[1]=1;
    for (int i=2;i<=m;++i)
        for (int j=0;j<i;++j)
            f[i]=(f[i]+c[i-1][j]*f[j])%mod;
    for (auto o:mp) ans=(ans*f[o.second])%mod;
    cout<<ans;
}

F - New Year and Rainbow Roads

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;


void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(0), cin.tie(0);
    int n;
    char ch;
    lint pb = 0, pr = 0, pg = 0, mr = 0, mb = 0, ans = 0, x;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> x >> ch;
        if (ch == 'R' || ch == 'G') {
            if (pr) {
                ans += x - pr;
                mr = max(mr, x - pr);
            }
            pr = x;
        }
        if (ch == 'B' || ch == 'G') {
            if (pb) {
                ans += x - pb;
                mb = max(mb, x - pb);
            }
            pb = x;
        }
        if (ch == 'G') {
            if (pg) ans += min(0LL, x - pg - mr - mb);
            pg = x;
            mr = mb = 0;
        }
    }
    cout << ans << endl;
    return 0;
}

G - New Year and Original Order

#pragma comment(linker, "/STACK:102400000,102400000")
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<string>
#include<functional>
#include<math.h>
//#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef queue<int> QI;


void makedata() {
    freopen("input.txt", "w", stdout);
    fclose(stdout);
}

const int mod = 1000000007;
lint dp[800][800][10][2];
string s;

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    //makedata();
    std::ios::sync_with_stdio(0), cin.tie(0);
    cin >> s;
    int n = s.size();
    reverse(s.begin(), s.end());
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i < 10; i++) dp[0][0][i][1] = 1;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= i; j++) {
            for (int k = 1; k < 10; k++) {
                for (int l = 0; l < 2; l++) {
                    for (int p = 0; p < 10; p++) {
                        (dp[i + 1][j + (p >= k)][k][(s[i] - '0' > p) || (l && (s[i] - '0' == p))] += dp[i][j][k][l]) %= mod;
                    }
                }
            }
        }
    }
    lint ans = 0;
    for (int i = 1; i < 10; i++) {
        lint t = 1;
        for (int j = 1; j <= n; j++, t = (t * 10 + 1) % mod) ans += dp[n][j][i][1] * t, ans %= mod;
    }
    cout << ans << endl;
    return 0;
}

H - New Year and Boolean Bridges

#include<bits/stdc++.h>
#define N 50
#define fr(i,n) for(int i=1;i<=n;i++)
using namespace std;
int n,i,j,x,S,an,nv,id,to[N],c[N],b[N],F[N],sz[N];bool v[N][N];
char s[N][N];
int gf(int x){return F[x]==x?x:F[x]=gf(F[x]);}
void uni(int x,int y){
    x=gf(x);y=gf(y);
    if(x!=y)F[x]=y,sz[y]+=sz[x];
}
int main(){
    scanf("%d",&n);
    fr(i,n)F[i]=i,sz[i]=1;
    fr(i,n){
        scanf("%s",s[i]+1);
        fr(j,n)if(i!=j)
            if(s[i][j]=='A')uni(i,j);
    }
    fr(i,n)if(gf(i)==i&&sz[i]>1)to[i]=++id;
    fr(i,n)fr(j,n)if(gf(i)==gf(j)&&s[i][j]=='X')return puts("-1"),0;
    fr(i,n)fr(j,n)if(s[i][j]=='X')v[to[gf(i)]][to[gf(j)]]=1;
    fr(i,id)b[i]=i;an=n;
    fr(T,9999){
        random_shuffle(b+1,b+id+1);nv=0;
        fr(i,id){
            x=b[i];S=0;
            fr(j,id)if(v[x][j])S|=1<<c[j];
            for(j=1;;j++)if(!(S>>j&1)){
                c[x]=j;
                break;
            }
            nv=max(nv,c[x]);
        }
        fr(i,id)c[i]=0;
        an=min(an,nv);
    }
    printf("%d
",n-1+an);
}