cf Round 607

A.Chain Reaction(DP+二分)

题意：一排有n个灯塔，每个灯塔给出坐标xi和力量yi,
每次从最右边依次点亮灯塔，每点亮一个灯塔，它左边的距离它yi范围内的灯塔将受到损坏。
现在允许在最右边>max(xi)处添加一座力量值yi的灯塔。
问最少只会损坏多少灯塔。

分析:因为我们是从右边点亮灯塔的，所以我们点亮我们添加的那座灯塔只会损坏连续个灯塔。最后就相当于从末尾的某一个灯塔开始点亮。
我们令dp[i]表示点亮第i座灯塔最少损坏多少灯塔。
于是我们对于每个dp[i],二分可以得到他前面的前驱。
所以dp[i]=dp[j]+1(j注意题目给出的灯塔并不是有序的，需要排序一遍。

# include 
# include <string.h>
# include 
# include 
# include 
# include 
# include 
# include 

View Code

 

B.Zuma(区间DP)

给出一串n个数字(n<=500).每次操作可以消掉一个回文串。然后补齐。
问最少需要操作多少次。

姿势很优雅的区间DP；
很容易想到dp[l][r]表示消掉[l,r]的回文串最少需要多少步。
但是在转移的过程中GG了，假如它先消中间的某一部分，然后再对齐再消，这样咋办。
于是我码了一个暴力判断字符串是否回文。结果TLE了。
仔细一想，因为1个数字显然是回文串。
对于[l,r]区间，我们枚举[l+1,r]内的一个k使得a[k]==a[l]，这时候我们可以先消[l+1,k-1].
再消a[l]和a[k]，我们注意到消[l+1,k-1]的最后一步一定会变成一个回文串，
因为a[l]==a[k], 所以我们消a[l,k]的步数就等于a[l+1,k-1].
即dp[l][k]==dp[l+1][k-1].
所以状态转移方程就是dp[l][r]=min(dp[l+1][r]+1,dp[l+1][k-1]+dp[k+1][r])(a[k]==a[l])
最后判断一下边界就行了。

# include 
# include <string.h>
# include 
# include 
# include 
# include 
# include 
# include 

View Code

 

C.Marbles(脑洞+hash)

#include 
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
const LL INF = 1E9+9;
const int MI = ~0u>>1;

int main()
{
    int n;
    string s1,s2;
    cin>>n>>s1>>s2;
    n--;
    for(int i=0;i)
    {
        switch(s2[i])
        {
            case 'N':s2[i]='S';break;
            case 'S':s2[i]='N';break;
            case 'W':s2[i]='E';break;
            case 'E':s2[i]='W';break;
        }
    }
    ULL v1=0,v2=0;
    const ULL seed=131;
    ULL wt=1;
    for(int i=n-1;i>=0;i--,wt*=131)
    {
        v1=v1+(s1[i]-'a')*wt;
        v2=v2*seed+s2[i]-'a';
        if(v1==v2)
        {
            printf("NO");
            return 0;
        }
    }
    printf("YES");
    return 0;
}

View Code

 

D.Power Tree(线段树维护dfn+逆元)

分析: 我们可以算出每一个节点对根节点的贡献因子mi。
即di是节点i的儿子节点数+1.
实际上mi就是从i到根节点的简单路径上的di的乘积。
当新加入一个节点u到节点p时。我们观察可以发现，仅仅改变了p和p的子树的mi。
显然是mi=mi*(dp+1)/dp. mu=mp。
我们需要一个数据结构可以 对一个区间进行乘，更新一个值，以及求一个区间的总和。
我们用线段树维护dfn序。
那么一个节点的子树就是一段连续的区间。
我们求一个节点的贡献时。显然就是sum同时除以他们的公共路径的mi。
由于乘法是一个浮点数。我们先累乘所有的分子，再累乘所有的分母，最后我们用乘法逆元
可以求出取模。

代码量有点受不了。。。

#include 
#include 
#include 
#pragma comment(linker, "/STACK:16000000")
using namespace std;

typedef long long ll;

const int mod = 1000000007;
const int Maxn = 200005;
const int Maxm = 1048576;

int n, q;
int val[Maxn];
int a[Maxn], b[Maxn], c[Maxn];
vector <int> neigh[Maxn];
int ch[Maxn];
int P[Maxn], cur, L[Maxn], R[Maxn];
int mult[Maxm];
int fl[Maxm], sum[Maxm];

void Traverse(int v)
{
    L[v] = ++cur;
    for (int i = 0; i < neigh[v].size(); i++)
        Traverse(neigh[v][i]);
    R[v] = cur;
}

void createMult(int v, int l, int r)
{
    mult[v] = 1;
    if (l < r) {
        int m = l + r >> 1;
        createMult(2 * v, l, m); createMult(2 * v + 1, m + 1, r);
    }
}

void updMult(int v, int l, int r, int a, int b, int val)
{
    if (l == a && r == b) mult[v] = ll(mult[v]) * val % mod;
    else {
        int m = l + r >> 1;
        if (a <= m) updMult(2 * v, l, m, a, min(m, b), val);
        if (m + 1 <= b) updMult(2 * v + 1, m + 1, r, max(m + 1, a), b, val);
    }
}

int getMult(int v, int l, int r, int x)
{
    int res = mult[v];
    if (l < r) {
        int m = l + r >> 1;
        if (x <= m) res = ll(res) * getMult(2 * v, l, m, x) % mod;
        else res = ll(res) * getMult(2 * v + 1, m + 1, r, x) % mod;
    }
    return res;
}

void Union(int v)
{
    sum[v] = (sum[2 * v] + sum[2 * v + 1]) % mod;
}

void downOn(int v, int val)
{
    fl[v] = ll(fl[v]) * val % mod;
    sum[v] = ll(sum[v]) * val % mod;
}

void Down(int v)
{
    if (fl[v] != 1) {
        downOn(2 * v, fl[v]); downOn(2 * v + 1, fl[v]);
        fl[v] = 1;
    }
}

void createSum(int v, int l, int r)
{
    fl[v] = 1;
    if (l == r) sum[v] = val[l];
    else {
        int m = l + r >> 1;
        createSum(2 * v, l, m); createSum(2 * v + 1, m + 1, r);
        Union(v);
    }
}

int getSum(int v, int l, int r, int a, int b)
{
    if (l == a && r == b) return sum[v];
    else {
        Down(v);
        int m = l + r >> 1;
        int res = 0;
        if (a <= m) res = (res + getSum(2 * v, l, m, a, min(m, b))) % mod;
        if (m + 1 <= b) res = (res + getSum(2 * v + 1, m + 1, r, max(m + 1, a), b)) % mod;
        return res;
    }
}

void multSum(int v, int l, int r, int a, int b, int val)
{
    if (l == a && r == b) downOn(v, val);
    else {
        Down(v);
        int m = l + r >> 1;
        if (a <= m) multSum(2 * v, l, m, a, min(m, b), val);
        if (m + 1 <= b) multSum(2 * v + 1, m + 1, r, max(m + 1, a), b, val);
        Union(v);
    }
}

void addSum(int v, int l, int r, int x, int val)
{
    if (l == r) sum[v] = val;
    else {
        Down(v);
        int m = l + r >> 1;
        if (x <= m) addSum(2 * v, l, m, x, val);
        else addSum(2 * v + 1, m + 1, r, x, val);
        Union(v);
    }
}

int Inv(int a)
{
    int p = mod - 2;
    int res = 1;
    while (p) {
        if (p & 1) res = ll(res) * a % mod;
        p >>= 1; a = ll(a) * a % mod;
    }
    return res;
}

int main()
{
    n = 1; scanf("%d %d", &val[n], &q);
    for (int i = 0; i < q; i++) {
        scanf("%d %d", &a[i], &b[i]);
        if (a[i] == 1) {
            scanf("%d", &c[i]);
            n++; P[n] = b[i];
            neigh[b[i]].push_back(n);
        }
    }
    Traverse(1);
    createMult(1, 1, R[1]);
    createSum(1, 1, R[1]);
    n = 1;
    for (int i = 0; i < q; i++)
        if (a[i] == 1) {
            n++;
            ch[b[i]]++;
            int tomult = ll(ch[b[i]] + 1) * Inv(ch[b[i]]) % mod;
            updMult(1, 1, R[1], L[b[i]], R[b[i]], tomult);
            multSum(1, 1, R[1], L[b[i]], R[b[i]], tomult);
            val[n] = c[i];
            tomult = getMult(1, 1, R[1], L[n]);
            addSum(1, 1, R[1], L[n], ll(tomult) * val[n] % mod);
        } else {
            int res = getSum(1, 1, R[1], L[b[i]], R[b[i]]);
            if (P[b[i]]) {
                int tomult = Inv(getMult(1, 1, R[1], L[P[b[i]]]));
                res = ll(res) * tomult % mod;
            }
            printf("%d\n", res);
        }
    return 0;
}

View Code

 

E.Cross Sum(待填坑)

 

转载于:https://www.cnblogs.com/lishiyao/p/6255967.html