BNU4286——Adjacent Bit Counts——————【dp】

Adjacent Bit Counts

Time Limit: 1000ms

Memory Limit: 65536KB

64-bit integer IO format:  %lld      Java class name: Main

Prev 

Submit  Status  Statistics  Discuss

  Next

Type: 

None

 

  None   Graph Theory       2-SAT       Articulation/Bridge/Biconnected Component       Cycles/Topological Sorting/Strongly Connected Component       Shortest Path           Bellman Ford           Dijkstra/Floyd Warshall       Euler Trail/Circuit       Heavy-Light Decomposition       Minimum Spanning Tree       Stable Marriage Problem       Trees       Directed Minimum Spanning Tree       Flow/Matching           Graph Matching               Bipartite Matching               Hopcroft–Karp Bipartite Matching               Weighted Bipartite Matching/Hungarian Algorithm           Flow               Max Flow/Min Cut               Min Cost Max Flow   DFS-like       Backtracking with Pruning/Branch and Bound       Basic Recursion       IDA* Search       Parsing/Grammar       Breadth First Search/Depth First Search       Advanced Search Techniques           Binary Search/Bisection           Ternary Search   Geometry       Basic Geometry       Computational Geometry       Convex Hull       Pick's Theorem   Game Theory       Green Hackenbush/Colon Principle/Fusion Principle       Nim       Sprague-Grundy Number   Matrix       Gaussian Elimination       Matrix Exponentiation   Data Structures       Basic Data Structures       Binary Indexed Tree       Binary Search Tree       Hashing       Orthogonal Range Search       Range Minimum Query/Lowest Common Ancestor       Segment Tree/Interval Tree       Trie Tree       Sorting       Disjoint Set   String       Aho Corasick       Knuth-Morris-Pratt       Suffix Array/Suffix Tree   Math       Basic Math       Big Integer Arithmetic       Number Theory           Chinese Remainder Theorem           Extended Euclid           Inclusion/Exclusion           Modular Arithmetic       Combinatorics           Group Theory/Burnside's lemma           Counting       Probability/Expected Value   Others       Tricky       Hardest       Unusual       Brute Force       Implementation       Constructive Algorithms       Two Pointer       Bitmask       Beginner       Discrete Logarithm/Shank's Baby-step Giant-step Algorithm       Greedy       Divide and Conquer   Dynamic Programming                    Tag it!

For a string of  n bits  x 1 ,  x 2 ,  x 3 , …,  x n,B the  adjacent bit count of the string ( AdjBC(x)) is given by

x 1 *x 2  + x 2 *x 3  + x 3 *x 4  + … + x n -1 *x n

which counts the number of times a 1 bit is adjacent to another 1 bit. For example:

AdjBC(011101101) = 3

AdjBC(111101101) = 4

AdjBC(010101010) = 0

Write a program which takes as input integers  n and  k and returns the number of bit strings  x of  n bits (out of 2 ⁿ) that satisfy AdjBC( x) =  k. For example, for 5 bit strings, there are 6 ways of getting AdjBC( x) = 2:

11100, 01110, 00111, 10111, 11101, 11011 

 

Input

The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. Each data set is a single line that contains the data set number, followed by a space, followed by a decimal integer giving the number (n) of bits in the bit strings, followed by a single space, followed by a decimal integer (k) giving the desired adjacent bit count. The number of bits (n) will not be greater than 100 and the parameters n and k will be chosen so that the result will fit in a signed 32-bit integer. 

 

Output

For each data set there is one line of output. It contains the data set number followed by a single space, followed by the number of n-bit strings with adjacent bit count equal to k. 

 

Sample Input

10

1 5 2

2 20 8

3 30 17

4 40 24

5 50 37

6 60 52

7 70 59

8 80 73

9 90 84

10 100 90

Sample Output

1 6

2 63426

3 1861225

4 168212501

5 44874764

6 160916

7 22937308

8 99167

9 15476

10 23076518


解题思路：用dp[i][j][k]来定义状态。i表示当前数字是第i位，j表示达到j值，k代表末尾是0还是1.由于当末尾为0对新加的一位没有要求，即j值不会变动，所以当dp[i][j][0]时转移方程为dp[i][j][0]=dp[i-1][j][0]+dp[i-1][j][1]。而当末尾为1时如果新加一位的值为1，会影响j的值。所以当dp[i][j][1]时dp[i][j][1]=dp[i-1][j-1][1]+dp[i-1][j][0]。

#include<bits/stdc++.h>

using namespace std;

int dp[500][500][2];

void DP(int n){

    memset(dp,0,sizeof(dp));

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

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

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

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

            dp[i][j][0]=dp[i-1][j][0]+dp[i-1][j][1];

            if(j){

                dp[i][j][1]=dp[i-1][j][0]+dp[i-1][j-1][1];

            }else{

                dp[i][j][1]=dp[i-1][j][0];

            }



        }

    }

}

int main(){

    int n;

    scanf("%d",&n);

    DP(110);

    while(n--){

        int t,ta,tb;

        scanf("%d%d%d",&t,&ta,&tb);

        cout<<t<<" "<<dp[ta][tb][0]+dp[ta][tb][1]<<endl;



    }

    return 0;

}