2018.09.09 DL24 Day2总结

今天挂的有点惨……

T1.forging

这道题自己在考试的时候想出来了……

这题是一个期望递推。我们首先考虑这么一件事，一枚硬币，你抛到正面停止，抛到反面继续抛，问期望抛的次数。是两次。我们假设期望抛x次，因为期望对于后面没有影响，所以有如下方程：

x = 0.5 × 0 + 0.5 × x + 1，x = 2.

那么我们就可以通过当前合成的概率知道合成的期望次数了。然后一次合成我们需要一把i级的武器，我们只需要1把i-2级的武器和期望次数把的i-1级的武器，所以我们就可以这样递推计算，然后结束。

结果一是因为自己智障的在两个0级刀合成的时候忘记取max，加上自己空间开的过大，100变0分可还行。

看下std……自己改完的代码好像丢了……

#include<cmath>
#include<cstdio>
#include<cctype>
#include<algorithm>
using namespace std;
typedef long long ll;
const int p=;
const int N=1e7+;
inline int read(){
    int X=,w=;char ch=;
    while(!isdigit(ch)){w|=ch=='-';ch=getchar();}
    while(isdigit(ch))X=(X<<)+(X<<)+(ch^),ch=getchar();
    return w?-X:X;
}
int inv[N],b[N],c[N],f[N];
inline int sub(int x,int y){
    x-=y;if(x<)x+=p;return x;
}
int main(){
    freopen("forging.in","r",stdin);freopen("forging.out","w",stdout);
    inv[]=;
    for(int i=;i<N;i++)inv[i]=(ll)(p-p/i)*inv[p%i]%p;

    int n=read();f[]=read();
    int bx=read(),by=read(),cx=read(),cy=read(),mod=read();
    b[]=by+;c[]=cy+;
    for(int i=;i<n;i++){
    b[i]=((ll)b[i-]*bx+by)%mod+;
    c[i]=((ll)c[i-]*cx+cy)%mod+;
    }
    f[]=(ll)((ll)c[]*inv[min(b[],c[])]%p+)*f[]%p;
    for(int i=;i<=n;i++)
    f[i]=((ll)c[i-]*inv[min(b[i-],c[i-])]%p*f[i-]%p+f[i-])%p;
    printf("%d\n",f[n]);
    return ;
}

T2.division

这道题当时做的时候没想出来什么……于是好像写了个暴力骗了20。

后来学姐说是CRT……？没大听懂，copy一下题解……

std：

#include <bits/stdc++.h>
#define enter putchar('\n')
#define space putchar(' ')
using namespace std;
template<class T>
void read(T &res)
{
    res = ;
    char c = getchar();
    T f = ;
    while(c < '' || c > '')
    {
        if(c == '-') f = -;
        c = getchar();
    }
    while(c >= '' && c <= '')
    {
        res = res *  + c - '';
        c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x)
{
    if(x < )
    {
        putchar('-');
        x = -x;
    }
    if(x >= )
    {
        out(x / );
    }
    putchar('' + x % );
}
int id;
int a[],tot,prime[];
bool nonprime[];
int mul(int a,int b,int MOD)
{
    return 1LL * a * b % MOD;
}
int fpow(int x,int c,int MOD)
{
    int res = ,t = x;
    while(c)
    {
        if(c & ) res = res * t % MOD;
        t = t * t % MOD;
        c >>= ;
    }
    return res;
}
int Calc(int p,int m)
{
    memset(nonprime,,sizeof(nonprime));
    tot = ;
    a[] = ;
    a[p] = ;
    for(int i =  ; i < p ; ++i)
    {
        if(!nonprime[i])
        {
            a[i] = fpow(i,m,p);
            prime[++tot] = i;
        }
        for(int j =  ; j <= tot ; ++j)
        {
            if(i * prime[j] > ) break;
            a[i * prime[j]] = a[i] * a[prime[j]] % p;
            nonprime[i * prime[j]] = ;
            if(i % prime[j] == ) break;
        }
    }
    int res = ;
    for(int i =  ; i <= p ; ++i)
    {
        int t = a[i] - i + p;
        if(t >= p) t -= p;
        res += (t == );
    }
    return res;
}
void Solve()
{
    int ans = ;
    int c,m;
    read(c);
    read(m);
    int p = ;
    for(int i =  ; i <= c ; ++i)
    {
        read(p);
        ans = mul(ans,Calc(p,m),);
    }
    out(ans);
    enter;
}
int main()
{
    freopen("division.in","r",stdin);
    freopen("division.out","w",stdout);
    read(id);
    int T;
    read(T);
    while(T--) Solve();
}

T3.money

这道题仍然是不会的状态……考试的时候骗到了10分。

正解是用倍增求出链上最小值，然后合并的时候启发式合并，用倍增记一下边的方向（？？？）

表示还是不懂……看一下std吧orz

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cassert>
#define space putchar(' ')
#define enter putchar('\n')
typedef long long ll;
using namespace std;
template <class T>
void read(T &x){
    char c;
    bool op = ;
    while(c = getchar(), c < '' || c > '')
        if(c == '-') op = ;
    x = c - '';
    while(c = getchar(), c >= '' && c <= '')
        x = x *  + c - '';
    if(op) x = -x;
}
template <class T>
void write(T x){
    if(x < ) putchar('-'), x = -x;
    if(x >= ) write(x / );
    putchar('' + x % );
}

const int N = , INF = 0x3f3f3f3f;
int n, m, lastans;
int ecnt, nxt[*N], go[*N], adj[N], edir[*N], emi[*N];
int sze[N], bel[N], dep[N];
int anc[N][], mi[N][], dir[N][];

void out(){
    for(int i = ; i <= n; i++)
        for(int j = ; anc[i][j]; j++)
            printf("anc[%d][%d] = %d, dir = %d, mi = %d\n", i, j, anc[i][j], dir[i][j], mi[i][j]);
}

void adde(int u, int v, int d, int w){
    go[++ecnt] = v;
    nxt[ecnt] = adj[u];
    adj[u] = ecnt;
    edir[ecnt] = d;
    emi[ecnt] = w;
}
void dfs(int u, int pre, int rt){
    bel[u] = rt;
    dep[u] = dep[pre] + ;
    for(int i = ; i < ; i++){
        anc[u][i + ] = anc[anc[u][i]][i];
        mi[u][i + ] = min(mi[u][i], mi[anc[u][i]][i]);
        dir[u][i + ] = dir[u][i] | dir[anc[u][i]][i];
    }
    for(int e = adj[u], v; e; e = nxt[e])
        if((v = go[e]) != pre){
            anc[v][] = u;
            mi[v][] = emi[e];
            dir[v][] = edir[e] ^ ;
            dfs(v, u, rt);
        }
}
void add(int u, int v, int w){
    adde(u, v, , w);
    adde(v, u, , w);
    int d = sze[bel[u]] > sze[bel[v]] ?  : ;
    if(d == ) swap(u, v);
    anc[u][] = v, mi[u][] = w, dir[u][] = d;
    sze[bel[v]] += sze[bel[u]];
    dfs(u, v, bel[v]);
}
int query(int u, int v){
    if(bel[u] != bel[v]) return ;
    int d = , ret = INF;
    if(dep[u] > dep[v])
        swap(u, v), d = ;
    for(int i = ; i >= ; i--)
        if(dep[v] - ( << i) >= dep[u]){
            if(dir[v][i] != ( ^ d)) return ;
            ret = min(ret, mi[v][i]);
            v = anc[v][i];
        }
    if(u == v) return ret;
    for(int i = ; i >= ; i--)
        if(anc[u][i] != anc[v][i]){
            if(dir[v][i] != ( ^ d) || dir[u][i] != ( ^ d)) return ;
            ret = min(ret, min(mi[v][i], mi[u][i]));
            u = anc[u][i];
            v = anc[v][i];
        }
    if(dir[v][] != ( ^ d) || dir[u][] != ( ^ d)) return ;
    ret = min(ret, min(mi[v][], mi[u][]));
    return ret;
}

int main(){
    freopen("money.in", "r", stdin);
    freopen("money.out", "w", stdout);
    read(n), read(m);
    for(int i = ; i <= n; i++)
        bel[i] = i, sze[i] = ;
    int op, a, b, c;
    while(m--){
        read(op), read(a), read(b);
        a = (a + lastans) % n + ;
        b = (b + lastans) % n + ;
        if(op == ) read(c), c = (c + lastans) % n + , add(a, b, c);
        else write(lastans = query(a, b)), enter;
    }

    return ;
}