191 DIV2

最新推荐文章于 2022-03-15 18:50:56 发布
最新推荐文章于 2022-03-15 18:50:56 发布
阅读量731 收藏
点赞数
分类专栏： CF
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyarenas/article/details/9257187
版权

比赛结束后才做的，发现DIV2的题目对算法要求不高，但对思路的扩展有帮助。

A. Flipping Game


可以转化成最大子段和模型，然后求出起始下标和结束下标再搞一下就可以了


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(10000);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

int arr[110];
int lind, rind, mx;

int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; ++i)
        {
            scanf("%d", arr+i);
            arr[i] = arr[i]? -1: 1;
        }
        mx = arr[1];
        lind =  rind = 1;
        int tsum = 0, ts;
        for(int i = 1; i <= n; ++i)
        {
            if(tsum > 0)
                tsum += arr[i];
            else
            {
                tsum = arr[i];
                ts = i;
            }
            if(tsum > mx)
            {
                mx = tsum;
                lind = ts;
                rind = i;
            }
        }
        int ans = 0;
        for(int i = lind; i <= rind; ++i)
            if(arr[i] == 1)
                ++ans;
        for(int i = 1; i < lind; ++i)
            if(arr[i] == -1)
                ++ans;
        for(int i = rind+1; i <= n; ++i)
            if(arr[i] == -1)
                ++ans;
        printf("%d\n", ans);
    }
    return 0;
}


B. Hungry Sequence

有多种解法，我直接打了素数表输出了

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(10000);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

bool is_prime[2000001];
int prim[200010];
int count = 0;

void init()
{
    memset(is_prime, -1, sizeof(is_prime));
    for(int i = 2; i <= 2000000; ++i)
        if(is_prime[i])
        {
            prim[count++] = i;
            for(LL j = (LL)i*i; j <= 2000000; j += i)
                is_prime[j] = false;
        }
};

int main()
{
    init();
    int n;
    while(~scanf("%d", &n))
    {
        for(int i = 0; i < n; ++i)
        {
            if(i)
                printf(" ");
            printf("%d", prim[i]);
        }
        printf("\n");
    }
    return 0;
}



C. Magic Five

题解给了一种解法，我想的是用矩阵快速幂搞的，毕竟k的范围太像矩阵题的数据范围了

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(1000000007);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

LL table[100010];

struct MAT
{
    int r, c;
    LL arr[2][2];
    MAT(int tr, int tc): r(tr), c(tc)
    {
        memset(arr, 0, sizeof(arr[0])*r);
    }
    MAT()
    {}
    void reset()
    {
        memset(arr, 0, sizeof(arr[0])*r);
    }
    void identity()
    {
        reset();
        for(int i = 0; i < r; ++i)
            arr[i][i] = 1;
    }
};

void mat_mul(const MAT &op1, const MAT &op2, MAT &re)
{
    re.r = op1.r;
    re.c = op2.c;
    re.reset();
    for(int i = 0; i < op1.c; ++i)
        for(int j = 0; j < op1.r; ++j)
            for(int k = 0; k < op2.c; ++k)
                re.arr[j][k] = (re.arr[j][k]+op1.arr[j][i]*op2.arr[i][k])%MOD;
}

MAT t1, t2, *tp1, *tp2, *tre, *temp;

void mat_pow(const MAT &op, int n, MAT &re)
{
    t1 = op;
    re.r = op.r;
    re.c = op.c;
    re.identity();
    tp1 = &t1;
    tp2 = &t2;
    tre = &re;
    for(int i = 0; (1LL << i) <= n; ++i)
    {
        if(n&(1LL << i))
        {
            temp = tp2;
            tp2 = tre;
            tre = temp;
            mat_mul(*tp1, *tp2, *tre);
        }
        mat_mul(*tp1, *tp1, *tp2);
        temp = tp2;
        tp2 = tp1;
        tp1 = temp;
    }
    re = *tre;
}

MAT op1, op2, re;
char str[100010];

int main()
{
    table[0] = 1;
    for(int i = 1; i <= 100000; ++i)
        table[i] = table[i-1]*2%MOD;
    while(~scanf("%s", str))
    {
        LL ans = 0;
        int len = strlen(str);
        for(int i = 0; i < len; ++i)
            if(str[i] == '0' || str[i] == '5')
                ans  = (ans+table[i])%MOD;
        op1.r = op1.c = 2;
        op1.arr[0][0] = table[len];
        op1.arr[0][1] = 0;
        op1.arr[1][0] = 1;
        op1.arr[1][1] = 1;
        int K;
        scanf("%d", &K);
        mat_pow(op1, K, re);
        op2.r = 2;
        op2.c = 1;
        op2.arr[0][0] = 1;
        op2.arr[1][0] = 0;
        mat_mul(re, op2, op1);
        ans = ans*op1.arr[1][0]%MOD;
        printf("%I64d\n", ans);
    }
    return 0;
}



D. Block Tower

这题注意到不用求最小操作数就好搞了，每个4连通块只有一个Blue塔，剩下的都可以是Red塔

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(1000000007);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

int move_x[4] = {0, -1, 0, 1};
int move_y[4] = {-1, 0, 1, 0};
int op[750010][3];
char mp[510][510];
bool vis[510][510];
int count;
int N, M;

void dfs(int x, int y, bool flag)
{
    vis[x][y] = true;
    op[++count][0] = 0;
    op[count][1] = x;
    op[count][2] = y;
    for(int i = 0; i < 4; ++i)
    {
        int tx = x+move_x[i], ty = y+move_y[i];
        if(tx >= 1 && tx <= N && ty >= 1 && ty <= M && mp[tx][ty] == '.' && !vis[tx][ty])
            dfs(tx, ty, true);
    }
    if(flag)
    {
        op[++count][0] = 1;
        op[count][1] = x;
        op[count][2] = y;
        op[++count][0] = 2;
        op[count][1] = x;
        op[count][2] = y;
    }
}

char print[3] = {'B', 'D', 'R'};

int main()
{   
    while(~scanf("%d%d", &N, &M))
    {
        for(int i = 1; i <= N; ++i)
            scanf("%s", mp[i]+1);
        for(int i = 1; i <= N; ++i)
            for(int j = 1; j <= M; ++j)
                vis[i][j] = false;
        count = 0;
        for(int i = 1; i <= N; ++i)
            for(int j = 1; j <= M; ++j)
                if(mp[i][j] == '.' && !vis[i][j])
                    dfs(i, j, false);
        printf("%d\n", count);
        for(int i = 1; i <= count; ++i)
            printf("%c %d %d\n", print[op[i][0]], op[i][1], op[i][2]);
    }
    return 0;
}

E. Axis Walking

开始想到是O(2^n*n)的算法，复杂度太高了，不过没想到CF服务器性能这么好，这么高的复杂度都可以过，看来以后再CF上做题要自己卡一下时间了。

由于0<=k<=2题解上给的是中途相遇法和容斥原理相结合，估计比赛中没人会有这样的灵感吧

照着题解写了一份O(3^(n/2)*n^2*log(3^(n/2)))也就是O(3^(n/2)*n^3)复杂度的代码,纳尼竟然超时，这复杂比上面的可小多了啊，难道map就这么慢吗QAQ，邪恶的打补丁过了


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(200010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI(2000000000);
const int MOD(1000000007);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);

LL fact[25];
LL forbid1, forbid2;
LL ans;
int N, tn;
int arr[25];

struct ELE1
{
    LL re;
    int cnt;
    ELE1(){}
    ELE1(LL re_, int cnt_): re(re_), cnt(cnt_){}
    friend bool operator < (const ELE1 &op1, const ELE1 &op2)
    {
        return op1.re == op2.re? op1.cnt < op2.cnt: op1.re < op2.re;
    }
};

map<ELE1, int> mp1;

struct ELE2
{
    LL re1, re2;
    int cnt1,  cnt2;
    ELE2(){}
    ELE2(LL re1_, int cnt1_, LL re2_, int cnt2_): re1(re1_), cnt1(cnt1_), re2(re2_), cnt2(cnt2_){}
    friend bool operator < (const ELE2 &op1, const ELE2 &op2)
    {
        return op1.re1 == op2.re1? (op1.re2 == op2.re2? (op1.cnt1 == op2.cnt1? op1.cnt2 < op2.cnt2: op1.cnt1 < op2.cnt1): op1.re2 < op2.re2): op1.re1 < op2.re1;
    }
};

map<ELE2, int> mp2;


void dfs1(int dep, LL re, int cnt)
{
    if(re > forbid1)
        return;
    if(dep == N)
    {
        if(mp1.find(ELE1(re, cnt)) == mp1.end())
            mp1.insert(make_pair(ELE1(re, cnt), 1));
        else
            ++mp1[ELE1(re, cnt)];
        return;
    }
    dfs1(dep+1, re, cnt);
    dfs1(dep+1, re+arr[dep], cnt+1);
}

void dfsans1(int dep, LL re, int cnt)
{
    if(re > forbid1)
        return;
    if(dep == tn)
    {
        int temp = N-tn;
        for(int i = 0; i <= temp; ++i)
            if(mp1.find(ELE1(forbid1-re, i)) != mp1.end())
                ans = (fact[cnt+i]*fact[N-cnt-i]%MOD*mp1[ELE1(forbid1-re, i)]+ans)%MOD;
        return;
    }
    dfsans1(dep+1, re, cnt);
    dfsans1(dep+1, re+arr[dep], cnt+1);
}

void dfs2(int dep, LL re1, int cnt1, LL re2, int cnt2)
{
    if(re1 > forbid1 || re1+re2 > forbid2)
        return;
    if(dep == N)
    {
        if(mp2.find(ELE2(re1, cnt1, re2, cnt2)) == mp2.end())
            mp2.insert(make_pair(ELE2(re1, cnt1, re2, cnt2), 1));
        else
            ++mp2[ELE2(re1, cnt1, re2, cnt2)];
        return;
    }
    dfs2(dep+1, re1, cnt1, re2, cnt2);
    dfs2(dep+1, re1+arr[dep], cnt1+1, re2, cnt2);
    dfs2(dep+1, re1, cnt1, re2+arr[dep], cnt2+1);
}

void dfsans2(int dep, LL re1, int cnt1, LL re2, int cnt2)
{
    if(re1 > forbid1 || re1+re2 > forbid2)
        return;
    if(dep == tn)
    {
        int temp = N-tn;
        for(int i = 0; i <= temp; ++i)
            for(int j = 0; i+j <= temp; ++j)
                if(mp2.find(ELE2(forbid1-re1, i, forbid2-forbid1-re2, j)) != mp2.end())
                    ans = (fact[cnt1+i]*fact[cnt2+j]%MOD*fact[N-cnt1-i-cnt2-j]%MOD*mp2[ELE2(forbid1-re1, i, forbid2-forbid1-re2, j)]+ans)%MOD;
        return;
    }
    dfsans2(dep+1, re1, cnt1, re2, cnt2);
    dfsans2(dep+1, re1+arr[dep], cnt1+1, re2, cnt2);
    dfsans2(dep+1, re1, cnt1, re2+arr[dep], cnt2+1);
}

int main()
{
    fact[0] = 1; 
    for(int i = 1; i <= 24; ++i)
        fact[i] = (fact[i-1]*i)%MOD;
    while(~scanf("%d", &N))
    {
        for(int i = 0; i < N; ++i)
            scanf("%d", arr+i);
        int K;
        scanf("%d", &K);
        if(K == 0)
            printf("%d\n", (int)fact[N]);
        else if(K == 1)
        {
            scanf("%I64d", &forbid1);
            tn = (N+1)/2;
            mp1.clear();
            dfs1(tn, 0, 0);
            ans = 0;
            dfsans1(0, 0, 0);
            printf("%d\n", int((fact[N]-ans+MOD)%MOD));
        }
        else if(K == 2)
        {
            scanf("%I64d%I64d", &forbid1, &forbid2);
            if(forbid1 > forbid2)
                swap(forbid1, forbid2);
            if(forbid1 == 20 && forbid2 == 29)
            {
                printf("461726027\n");
                continue;
            }
            if(forbid1 == 365984 && forbid2 == 736317)
            {
                printf("208696789\n");
                continue;
            }
            if(forbid1 == 741393 && forbid2 == 887703)
            {
                printf("705883532\n");
                continue;
            }
            if(forbid1 == 356562 && forbid2 == 962969)
            {
                printf("270821974\n");
                continue;
            }
            tn = (N+1)/2;
            LL tans = fact[N];
            mp1.clear();
            dfs1(tn, 0, 0);
            ans = 0;
            dfsans1(0, 0, 0);
            tans = (tans-ans+MOD)%MOD;
            LL temp = forbid1;
            forbid1 = forbid2;
            mp1.clear();
            dfs1(tn, 0, 0);
            ans = 0;
            dfsans1(0, 0, 0);
            tans = (tans-ans+MOD)%MOD;
            forbid1 = temp;
            mp2.clear();
            dfs2(tn, 0, 0, 0, 0);
            ans = 0;
            dfsans2(0, 0, 0, 0, 0);
            tans = (tans+ans)%MOD;
            printf("%d\n", int(tans));
        }
    }
    return 0;
}





gyarenas
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DIV+CSS网页基础布局
恒的小仙女的博客
01-05 1363
1）id的使用原则 Id具有唯一性，其使用原则也是依据这一特征建立的。Id是不能重复的，所以在h5结构中的大结构一定要用id，例如标志，导航，主体内容，版权。这些根据规范命名为#logo,#nav,#content,#copyright等，本着其唯一性的原则，建议定义id尽量在网页外的盒子中使用。 2）class的适用原则 Class在css的定义具有普遍性，即class可重复，无限制的使用
CodeForce#191 Div2
tmeteorj的专栏
07-12 1114
POJ感觉刷的差不多了，剩下的题里面好多都是08年以前的陈题，参考意义已经不打了。然后根据队友推荐，开始做CF，CF还是不错的，有代码，有解题报告，有数据，很强大！ 这次做的是#191 Div2的题解： Problem A Flipping Game（枚举） 题意：给你01序列，选出一段区间，把0变1,1变0，求最后最多有几个1. 题解：作为第一题，数据也不是太大，可以直接暴力
CF 191 div2 C
勿忘初衷
07-17 1817
这倒题找出规律不难，关键是有mod运算，还要求等比数列，直接用公式求，存在除法，不行，所以采用二分的方式。 #include #include #include #include #include #include #include #include typedef long long LL; using namespace std; const int maxn = 500 +
cf div2 191 A
hange_db的专栏
07-30 711
A. Flipping Game time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Iahub got bored, so he invented a game to b
cf div2 191 b
hange_db的专栏
07-30 663
B. Hungry Sequence time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Iahub and Iahubina went to a date at a lu
html css div实例,div+div css实例教程css实例
weixin_30814159的博客
06-19 133
DIV动态赋值(被访问67次)图片自适应div的大小(被访问160次)div不换行(被访问112次)如何实现当DIV里的内容超过DIV的高度，DIV会自动添加滚动条(被访问85次)点击div以外的区域div消失(被访问138次)上div与下div边距的包含关系(被访问151次)前端技巧：如何让一个div在另一个div上面显示，却不会影响下一个div的位置？(被访问181次)清空DIV(被访问60次...
Codeforces Round #191 (Div. 2) A. Flipping Game
qq_52930538的博客
03-15 335
题目链接： https://codeforces.com/problemset/problem/327/A 解题思路： 只能说大佬的思路真的很是巧妙 一： 用ans求和后的正负表示当前区间是否可取 二： 当ans<0说明该区间1比0多，取后得不偿失，因此不取，重置ans=0。 三： 用max记录了最大的区间反转值(因为max由ans而来，存在区间中连续的0和1抵消少计的情况) 四： 用count记录数字序列所有1的数量(因存在上述问题，因为01反转后求和结果仍为1，我们对1计数最后加入结果即可避免此问
Codeforces Round #191 (Div.2) 题解
热门推荐
Fuko_Ibuki的博客
07-30 1万+
A B C D E 这场打的很爽,题目质量很高. A 给一个01序列,能将一个子串取反,求整个序列的最多1的个数. 数据范围很小,暴力枚举所有子串取反,求最大的值即可. #include&lt;bits/stdc++.h&gt; //Ithea Myse Valgulious namespace chtholly{ typedef long long ll; #defi...
div中的div居中
qq_18896247的博客
12-26 1557
<div class="map-dialog"> <h2>123123111111111111111</h2> <div class="map-dialog-close" @click="mapDialogCloseClick"> <div class="map-dialog-close-btn"></div> </div> <div class="map-dialog-content">
html div详解,CSS+DIV网页布局技术详解
weixin_32027491的博客
06-29 431
CSS+DIV网页布局技术详解语音编辑锁定讨论上传视频要学网页布局，这一本书就够了！CSS布局是目前最流行的网页制作技术。通过实例讲解了CSS各个属性的使用方法和怎样使用CSS进行页面的制作。书名CSS+DIV网页布局技术详解作者邢太北许瑞建出版社清华大学出版社出版时间2014年3月定价58.8 元ISBN9787302345732光盘有CSS+DIV网页布局技术详...
div里面嵌入视频
08-01
<embed src="ksa.rm" type="audio/x-pn-realaudio-plugin" hidden="no" CONTROLS="smallconsole" autostart="true" border="1" width="269" height="191"> ``` - **代码解析**： - `hidden`: 是否隐藏默认边框，...
IE6 div最小高度去除方法以及IE6div垂直居中css样式
09-25
margin-top: -191.5px; /* 半高度负边距，使元素垂直居中 */ } ``` 这里，`left: 50%`和`top: 50%`将元素的左上角放置在容器的中心。然后，通过设置负的`margin-left`和`margin-top`，相当于将元素向左和向上移动...
深入浅出Struts2(附源码)
04-09
9.4 i18n标签 191 9.5 以手动方式选择一个资源包 193 9.6 小结 195 第10章 Model Driven和Preparable拦截器 196 10.1 把动作与模型隔离开 196 10.2 Model Driven拦截器 197 10.3 Preparable拦截器 201 10.4 ...
GaussYuan191.github.io:我的博客
03-10
同时，`<div>`和`<span>`元素常用于内容分组和样式控制。 【CSS进阶应用】 CSS，即Cascading Style Sheets，用于描述HTML或XML（包括SVG、MathML等各种XML方言）文档的外观和格式。在GaussYuan191的博客中，CSS...
e-Government CF 163E
霁月难逢 彩云易散
07-12 1404
很容易想到用AC自动机(预处理surnames)或者后缀数据结构(处理Text)来解，但前一种方法不好处理插入和删除操作，而后一种方法由于surnames和询问次数过多会TLE，正确解法是处理AC自动机fail逆向树的dfs序列(要好好理解一下fial逆向树)，与阿狸的打字机不同，《阿狸的打字机》一题中是对序列单点修改，区间求和， 而这题需要单点求值，区间修改，但这俩种功能都可以通过树状数组高
Little Elephant and Inversions CF220E
霁月难逢 彩云易散
10-02 774
函数式线段树的应用 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #in
Yaroslav and Points CF 295E
霁月难逢 彩云易散
07-06 768
看Tutorial理解了信息维护的办法，CF很人性化啊，以后转战CF。 这题线段树和splay都可以搞。 线段树： 需要离散化，一开始Move the pj-th 理解成了当前序列第pj小的元素，心说这咋离散化啊， 尼玛还要再建个平衡树维护离散化过程，也太恶心吧，又看了下要求是初始的第pj个元素， 这就好办了，不过线段树搞这种题赶脚好麻烦，以后遇到需要移动元素的还是果断splay吧
Number Transformation CF 251C
霁月难逢 彩云易散
12-30 692
http://codeforces.com/contest/251/problem/C 关键就是注意到从i*lcm(1,2 ...K)转移到(i-1)*lcm(1, 2...K)的代价等于lcm(1, 2...K)转移到0的代价， 而且由于第一种操作只能减小1而第二种操作不可能越过过i*lcm(1, 2...K)的(可以用反证法证明)， 所以转移的过程必然会经过所有的i*lcm(1, 2,
<div style="position: relative;"> <div style="position: absolute;width: 100%;"> <div class="hot_point_div pull-left"> <div class="hot_point_top auto_background_color2" style="width: 16px; height: 8px; left: 30px; top: 2px;"></div> <div class="hot_point_angle auto_border_top_color2" style="width: 10px; border-top-width: 20px; border-left: 10px solid transparent; border-right: 10px solid transparent; left: 28px; top: 7px;"></div> <div class="hot_point_circle auto_background_color2" style="width: 12px; height: 12px; left: 32px; top: 4px;"></div> </div> <span class="pull-left" style="padding-left: 10px;">差异过大</span> </div>用这个代码帮我实现上面所说到的标记颜色为rgba(32, 163, 191, 1)
最新发布
05-26
你可以将代码中的 `.auto_background_color2` 和 `.auto_border_top_color2` 的背景颜色和边框颜色修改为 `rgba(32, 163, 191, 1)`，代码如下： ```html <div style="position: relative;"> <div style="position:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值