BZOJ 4321: queue2( dp )

dp(i, j, 1)表示前i个, 有j对是不合法的, i和i-1是在一起的.

dp(i, j, 0)表示前i个, 有j对是不合法的, i和i-1不在一起的.

转移我们只需考虑是多了一对不合法的还是少了一对不合法的, 或者是不变, 考虑当前i和i-1,i-2的位置的影响就可以了.

dp(i, j, 1) = 2*dp(i-1, j-1, 0) + dp(i-1, j-1, 1) + dp(i-1, j, 1)

dp(i, j, 0) = (i-j-2)*dp(i-1, j, 0) + (j+1)*dp(i-1, j+1, 0) + (i-j-1)*dp(i-1,j,1) + j*dp(i-1, j+1, 1)

这道题貌似还有递推式....

---------------------------------------------------------------------------------

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

typedef long long ll;

const int maxn = 1009;

const int MOD = 7777777;

int dp[2][maxn][2], N;

inline void upd(int &x, int t) {

if((x += t) >= MOD)

x -= MOD;

}

int main() {

scanf("%d", &N);

int c = 0, p = 1;

memset(dp[c], 0, sizeof dp[c]);

dp[c][0][0] = 1;

for(int i = 2; i <= N; i++) {

swap(c, p);

memset(dp[c], 0, sizeof dp[c]);

for(int j = 0; j < i; j++) {

dp[c][j][1] = dp[p][j][1];

if(j) {

upd(dp[c][j][1], dp[p][j - 1][0]);

upd(dp[c][j][1], dp[p][j - 1][0]);

upd(dp[c][j][1], dp[p][j - 1][1]);

}

dp[c][j][0] = (ll(dp[p][j + 1][0]) * (j + 1) + ll(j) * dp[p][j + 1][1]) % MOD;

if(i >= j + 2)

upd(dp[c][j][0], (ll(dp[p][j][0]) * (i - j - 2) + ll(dp[p][j][1]) * (i - j - 1)) % MOD);

}

}

printf("%d\n", dp[c][0][0]);

return 0;

}

---------------------------------------------------------------------------------

4321: queue2

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 104  Solved: 54
[Submit][Status][Discuss]

Description

n 个沙茶,被编号 1~n。排完队之后,每个沙茶希望,自己的相邻的两

人只要无一个人的编号和自己的编号相差为 1(+1 或-1)就行;

现在想知道,存在多少方案满足沙茶们如此不苛刻的条件。

Input

只有一行且为用空格隔开的一个正整数 N,其中 100%的数据满足 1≤N ≤ 1000;

Output

一个非负整数,表示方案数对 7777777 取模。

Sample Input

4

Sample Output

2
样例解释:有两种方案 2 4 1 3 和 3 1 4 2

HINT

Source

时间: 2024-08-05 05:25:19

BZOJ 4321: queue2( dp )的相关文章

bzoj 4321: queue2

4321: queue2 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 475  Solved: 287[Submit][Status][Discuss] Description n 个沙茶,被编号 1~n.排完队之后,每个沙茶希望,自己的相邻的两 人只要无一个人的编号和自己的编号相差为 1(+1 或-1)就行: 现在想知道,存在多少方案满足沙茶们如此不苛刻的条件. Input 只有一行且为用空格隔开的一个正整数 N,其中 100%的数据满足 1

bzoj 1597 斜率DP

1597: [Usaco2008 Mar]土地购买 Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 5115  Solved: 1897[Submit][Status][Discuss] Description 农夫John准备扩大他的农场,他正在考虑N (1 <= N <= 50,000) 块长方形的土地. 每块土地的长宽满足(1 <= 宽 <= 1,000,000; 1 <= 长 <= 1,000,000). 每块土地

bzoj 3668 数位DP

收获: 1.如果有很多位操作,并且不包含+-×/等高级运算,那么可以一位一位考虑,如果求一个最优解,可以尝试逐位确定,这道题因为原始攻击值有范围,那么就需要数位DP. 1 /************************************************************** 2 Problem: 3668 3 User: idy002 4 Language: C++ 5 Result: Accepted 6 Time:288 ms 7 Memory:804 kb 8 **

bzoj 1017 tree dp

这道题几经波折啊. 最开始和vfleaking一样,把题意理解错了,认为一个装备可能被多个装备依赖,然后想不出来,去看题解. 发现自己理解错了题意,自己想想,其实也不难想到dp[i][j][k]表示“i号节点代表的子树,用掉j的钱,给父亲预留k个自己(但还是父亲付钱)”的状态,写出来交上去就是T, 开始以为是常数问题,优化半天还是T,看了他人AC代码,才发现自己算法有一定问题:重复计算了很多东西. 树形动规,一般在大的树规下,每个节点还会对儿子们来一次”资源分配“,一般是用背包解决,这道题也是这

BZOJ 1996 合唱队(DP)

考虑从最后的队形开始依次还原最初的队形. 对于当前的队形,要么选最左边的,要么选最右边的. 如果选了左边的,那么下次选择的一定是大于它的.右边的同理. 所以定义dp[mark][l][r]为区间[l,r]的选择状态为mark的方法数. 然后记忆化搜索一下就可以了. # include <cstdio> # include <cstring> # include <cstdlib> # include <iostream> # include <vect

BZOJ 1833 数位DP

思路: 数位DP f[i][j][k]表示走到第i位 开头位j 数字k 出现的次数 $f[i][j][k]+=f[i-1][l][k];$$f[i][j][j]+=base[i]$ calc的时候要有特殊的技巧...(我看题解学会的) //By SiriusRen #include <cstdio> #include <cstring> #include <algorithm> using namespace std; #define int long long int

BZOJ 1068 (区间DP)

题意:字符串的压缩,f[l][r][0]代表还没M,f[l][r][1]代表有M. 1 #include<cstdio> 2 #include<cmath> 3 #include<cstring> 4 #include<algorithm> 5 #include<iostream> 6 int f[55][55][2],n; 7 char s[555]; 8 bool ok(int l,int r){ 9 int len=(r-l+1)/2; 1

bzoj 3851: 2048 dp优化

3851: 2048 Time Limit: 2 Sec  Memory Limit: 64 MBSubmit: 22  Solved: 9[Submit][Status] Description Teacher Mai is addicted to game 2048. But finally he finds it's too hard to get 2048. So he wants to change the rule: You are given some numbers. Every

bzoj 1996 区间dp

1996: [Hnoi2010]chorus 合唱队 Time Limit: 4 Sec  Memory Limit: 64 MBSubmit: 1727  Solved: 1115[Submit][Status][Discuss] Description Input Output Sample Input 4 1701 1702 1703 1704 Sample Output 8 HINT 要想知道[l,r]的初始队形的方案数,如果我们知道[l,r-1]和[l+1,r]有几种初始方案的话似乎就