Two HDU - 5791 (DP)

本文探讨了一道经典的动态规划问题——求两个序列的最长公共子序列的数量,并提供了一个具体的实现示例。通过状态转移方程,有效地解决了该问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Alice gets two sequences A and B. A easy problem comes. How many pair of sequence A’ and sequence B’ are same. For example, {1,2} and {1,2} are same. {1,2,4} and {1,4,2} are not same. A’ is a subsequence of A. B’ is a subsequence of B. The subsequnce can be not continuous. For example, {1,1,2} has 7 subsequences {1},{1},{2},{1,1},{1,2},{1,2},{1,1,2}. The answer can be very large. Output the answer mod 1000000007.
Input
The input contains multiple test cases.

For each test case, the first line cantains two integers N,M(1≤N,M≤1000)N,M(1≤N,M≤1000). The next line contains N integers. The next line followed M integers. All integers are between 1 and 1000.
Output
For each test case, output the answer mod 1000000007.
Sample Input
3 2
1 2 3
2 1
3 2
1 2 3
1 2
Sample Output
2
3
dp题,原型是最长公共子序列,只不过这个要求个数。
状态:

dp[x][y]:a1xb1y

状态转移方程:
a[x]=b[y]dp[x][y]=dp[x][y1]+dp[x1][y]+1
dp[x][y]=dp[x][y1]+dp[x1][y]dp[x1][y1]
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mod 1000000007
using namespace std;
int n,m;
int dp[1003][1003];
int a[1003],b[1003];
int solve(int x,int y)
{
    if(dp[x][y]!=-1)
        return dp[x][y];
    if(a[x]==b[y])
        return dp[x][y]=(solve(x,y-1)+solve(x-1,y)+1)%mod;
    int temp=solve(x,y-1)+solve(x-1,y)-solve(x-1,y-1);
    if(temp<0)
        return dp[x][y]=(temp+mod)%mod;
    else
        return dp[x][y]=temp%mod;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",a+i);
        for(int i=1;i<=m;i++)
            scanf("%d",b+i);
        memset(dp,-1,sizeof(dp));
            for(int i=0;i<=1000;i++)
        dp[i][0]=0,dp[0][i]=0;
        printf("%d\n",solve(n,m));
    }
    return 0;
}
### HDU OJ 1063 Problem Solution in C Language The provided code snippet appears to be incomplete and does not directly correspond to the specific requirements of HDU OJ 1063. For solving problems on platforms like HDU OJ, it is crucial to understand both the problem statement thoroughly and apply appropriate algorithms or data structures. For HDU OJ 1063 titled "Fill Blank," which involves filling blanks based on given conditions, an efficient approach can involve dynamic programming techniques combined with careful input parsing and output formatting[^1]. Below is a more structured way to tackle this kind of problem using C: ```c #include <stdio.h> #include <string.h> #define MAXN 1005 // Assuming maximum length as per constraints char str[MAXN]; int dp[MAXN][MAXN]; void solve(int n) { memset(dp, 0, sizeof(dp)); for (int len = 2; len <= n; ++len) { // Length from smallest non-trivial case upwards for (int i = 0; i + len - 1 < n; ++i) { int j = i + len - 1; if (str[i] == '(' && str[j] == ')') { dp[i][j] = dp[i + 1][j - 1] + 2; } for (int k = i; k < j; ++k) { dp[i][j] = ((dp[i][j]) > (dp[i][k] + dp[k + 1][j])) ? (dp[i][j]) : (dp[i][k] + dp[k + 1][j]); } } } printf("%d\n", dp[0][n - 1]); // Output result according to sample outputs } int main() { while (~scanf("%s", str)) { int n = strlen(str); solve(n); // Process each test case individually } return 0; } ``` This program reads strings composed mainly of parentheses `(` and `)` characters, calculates how many pairs are correctly matched by applying dynamic programming principles, and prints out results accordingly. The core idea lies within maintaining a two-dimensional array where `dp[i][j]` represents the longest valid substring between positions `i` and `j`.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值