Codeforces 106 DIV2 ACD

B表示完全看不懂。。就不弄了。。

E字符串先不管了。到时候系统学下字符串再处理

A

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
int src[13];
int main()
{
    int K;
    scanf("%d",&K);
    for (int i = 0; i < 12; i++) scanf("%d",&src[i]);
    sort(src,src+12);
    int ans  = 0 ,sum  = 0, cas = 11;
    while (true)
    {
        if (sum >= K) break;
        if (ans == 13) break;
        sum += src[cas];
        cas--;
        ans++;
    }
    if (ans == 13) puts("-1");
    else printf("%d\n",ans);
    return 0;
}

C

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
#define MAXN 100005
int N;
struct node
{
    int id;
    int val;
    friend bool operator < (const node & a,const node &b)
    {
        return a.val < b.val;
    }
}src[MAXN];
LL sum[MAXN];
node stl[MAXN],str[MAXN];
int main()
{
    scanf("%d",&N);
    sum[0] = 0;
    for (int i = 1; i <= N; i++)
    {
        scanf("%d",&src[i].val);
        src[i].id = i ;
        sum[i] = sum[i - 1] + src[i].val;
    }
    sort(src + 1, src + 1 + N);
    int topl = 1 ,topr = 1;
    if (N % 2 == 0)
    {
       for (int i = 1; i  <= N; i++)
        {
            if (i % 2 == 0)  stl[topl++] =src[i];
            else str[topr++] = src[i];
        }
        printf("%d\n",N / 2);
        for (int i = 1; i < topl; i++) printf("%d ",stl[i].id);
        putchar(‘\n‘);
        printf("%d\n",N / 2);
        for (int i = 1; i < topr; i++) printf("%d ",str[i].id);
        putchar(‘\n‘);
    }
    else
    {
        for (int i = 1; i <= N; i += 2)
            stl[topl++] =src[i];
        for (int i = 2; i <= N; i += 2)
            str[topr++] = src[i];
        printf("%d\n",N / 2 + 1);
        for (int i = 1; i < topl; i++ ) printf("%d ",stl[i].id);
        putchar(‘\n‘);
        printf("%d\n", N / 2);
        for (int i = 1; i < topr; i++) printf("%d ",str[i].id);
        putchar(‘\n‘);
    }
    return 0;
}

D

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b) {return a % b == 0 ? b : gcd(b, a % b);}
#define MOD 1000000007
char input[720];
struct node
{
        char res;
        int id;
}src[720];
int G[720];
node sta[720];
LL dp[720][720][4][4];
void calcu(int l ,int r)
{
        if (l >= r) return ;
        if (l  + 1 == r)
        {
                dp[l][r][0][1] = 1;
                dp[l][r][1][0] = 1;
                dp[l][r][2][0] = 1;
                dp[l][r][0][2] = 1;
        }
        if (G[l] == r)
        {
                calcu(l + 1,r - 1);
                for (int i = 0 ; i < 3; i++)
                        for (int j = 0; j < 3; j++)
                {
                        if (j != 1) dp[l][r][0][1] = (dp[l][r][0][1] + dp[l + 1][r - 1][i][j]) % MOD;
                        if (j != 2) dp[l][r][0][2] = (dp[l][r][0][2] + dp[l + 1][r - 1][i][j]) % MOD;
                        if (i != 1) dp[l][r][1][0] = (dp[l][r][1][0] + dp[l + 1][r - 1][i][j]) % MOD;
                        if (i != 2) dp[l][r][2][0] = (dp[l][r][2][0] + dp[l + 1][r - 1][i][j]) % MOD;
                }
                return ;
        }
        else
        {
                 int t = G[l];
                 calcu(l,t);
                 calcu(t + 1, r);
                 for (int i = 0 ; i < 3; i++)
                        for (int j = 0 ; j < 3; j++)
                           for (int m = 0; m < 3; m++)
                               for (int n = 0 ; n < 3; n++)
                 {
                         if (!( (m == 1 && n == 1) || (m == 2 && n == 2)))
                             dp[l][r][i][j] = (dp[l][r][i][j] + (dp[l][t][i][m] * dp[t + 1][r][n][j]) % MOD) % MOD;
                 }
        }
}
int main()
{
        while (scanf("%s",input + 1) != EOF)
        {
                int len = strlen(input + 1);
                int top = 1;
                for (int i = 1; i <= len; i++)
                {
                        if (input[i] == ‘(‘)
                        {
                                node tmp;
                                tmp.id = i;
                                tmp.res = input[i];
                                sta[top++] = tmp;
                        }
                        else
                        {
                                if (sta[top - 1].res == ‘(‘)
                                {
                                        G[i] = sta[top - 1].id;
                                        G[sta[top - 1].id] = i;
                                        top--;
                                }
                                else
                                {
                                        node tmp;
                                        tmp.id = i;
                                        tmp.res = input[i];
                                        sta[top++] = tmp;
                                }
                        }
                }
                memset(dp,0,sizeof(dp));
                calcu(1,len);
                LL ans = 0;
                for (int i = 0 ; i < 3; i++)
                        for (int j = 0 ; j < 3; j++)
                        ans = (ans + dp[1][len][i][j]) % MOD;
                printf("%I64d\n",ans % MOD);
        }
        return 0;
}

时间: 2024-10-10 21:34:30

Codeforces 106 DIV2 ACD的相关文章

Codeforces 583 DIV2 Robot&#39;s Task 贪心

原题链接:http://codeforces.com/problemset/problem/583/B 题意: 就..要打开一个电脑,必须至少先打开其他若干电脑,每次转向有个花费,让你设计一个序列,使得总花费最小. 题解: 就傻傻的走就好..从左走到右,再走回来,更新序列和答案就好. 代码: #include<iostream> #include<cstring> #include<algorithm> #include<cstdio> #define MA

Codeforces #180 div2 C Parity Game

// Codeforces #180 div2 C Parity Game // // 这道题的题目意思就不解释了 // // 题目有那么一点难(对于我而言),不多说啦 // // 解题思路: // // 首先如果a串和b串相等,不多说直接YES // 如果b串全是0,直接YES // 注意到a串有一个性质,1的个数不会超过本身的加1. // a有个1的上限设为x,b有个1的个数设为y,则如果x < y // 那么直接NO. // // 现在一般情况下,就是模拟啦,找到a的后缀和b的前缀一样的

Codeforces #246(div2)

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <ti

Codeforces #245(div2)

A:A. Points and Segments (easy) 题目看了n久,开始觉得尼玛这是div2的题目么,题目还标明了easy.. 意思是给你一n个点,m个区间,在n个点上放蓝球或者红球,然后让你找一种选择方案使得m个区间内的蓝球和红球数量之差不超过1. 开始想过用dfs,不过这只是div2的A题而已.. 然后想了下,直接输出010101序列不就可以么. 交了一发,发现要先排个序,再输出就可以了. AC代码: #include<iostream> #include<cstdio&g

codeforces#327 div2

codeforces#327 div2 这场状态不好有点可惜,题目都不难,而且很好.. A题:水题. #include<bits/stdc++.h> #define REP(i,a,b) for(int i=a;i<=b;i++) #define MS0(a) memset(a,0,sizeof(a)) #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 using namespace std; typedef lo

codeforces#FF(div2) DZY Loves Sequences

n个数,可以任意改变其中一个数,求最长的上升子区间长度 思路:记录一个from[i]表示从位置i的数开始最长的上升区间长度 记录一个to[i]表示到位置i的数所能达到的最长上升区间长度 枚举要改变的数的位置i,此时能达到的长度为to[i - 1] + from[i + 1] + 1,取最大值 //#pragma comment(linker, "/STACK:102400000,102400000") //HEAD #include <cstdio> #include &l

Codeforces 106 C Buns【多重背包】

今天拉了一场CF,做了一下,略坑啊...首先105A题,竟然卡精度,小数点两位卡精度,需要给他加一个1e-6,算是见识了 题目:Codeforces 106 C Buns 题意:给出一些n克面,以及m种馅儿,每种馅儿做面包需要的面的克数和馅儿的克数以及馅儿的总克数,面也可以单独做面包,然后每一种面包都有价格,求做的面包的总价格最高? 分析:很贱的题目啊,读了之后就开始贪心,贪心竟然过了10组数据,然后我以为有漏洞,后来发现是个多重背包.dp的题目最怕用贪心做了,幸亏发现了. 标准的多种背包,转化

Codeforces 258 Div2

A题,n*m根木棍,相交放置,轮流取走相交的两根,最后谁不能行动,则输掉. min(n,m)&1 为1则先取者赢. B题,给定一个长度为n,且各不相同的数组,问能否通过交换连续一段L....R使得变成单调递增. 如果一开始就是递增的,那么直接输出L...R就是1 1,交换一个就行了:否则判断中间是否有且一段单调递减,且两端交换后使得数组递增. 代码: 1 //Template updates date: 20140718 2 #include <iostream> 3 #include

Codeforces #263 div2 解题报告

比赛链接:http://codeforces.com/contest/462 这次比赛的时候,刚刚注册的时候很想好好的做一下,但是网上喝了个小酒之后,也就迷迷糊糊地看了题目,做了几题,一觉醒来发现rating掉了很多,那个心痛啊! 不过,后来认真的读了题目,发现这次的div2并不是很难! 官方题解:http://codeforces.com/blog/entry/13568 A. Appleman and Easy Task 解析: 一个水题,判断每个细胞周围是否都是有偶数个相邻细胞.   代码