数据结构—Problem B: 子序列问题(线性表)

Problem B: 子序列问题(线性表)

Time Limit: 1 Sec   Memory Limit: 128 MB
Submit: 339   Solved: 204
[ Submit][ Status][ Web Board]

Description

两个整数序列A=a1,a2,a3,…,am和B=b1,b2,b3,…,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的子序列,代码给出如下,请修改~

本题只需提交修改部分

#include<stdio.h>
#include<malloc.h>
struct node             //定义结构体
{
    int data;
    struct node *next;
};
struct node *creat(int n)
{
    struct node *head,*p,*q; //head是头节点,p指向新开辟的节点,q指向已连接的上一个节点
    head=(struct node *)malloc(sizeof(struct node));//给head开辟一个节点
    q = head;  //q节点连接到head上
    while(n--)  //开辟n个新节点,逐个连到链表上
    {
        p=(struct node *)malloc(sizeof(struct node));
        scanf("%d",&p->data);//p该连在q后边吧?
        q->next = p;
        q = p;

    }
    q->next = NULL;//链表结束
    return head;
}
void destroy(struct node *head)
{
 struct node *p;
 while(head!=NULL)
 {
  p=head->next;
  delete(head);
  head=p;
 }
}

int main()//建两条链表p,q
{
    int m,n,count=0;
    struct node *head1,*head2,*p,*q;
    scanf("%d",&m);
    head1 = creat(m);
    scanf("%d",&n);
    head2 = creat(n);
    q=head2->next;
    p = head1->next;
    while(q != NULL)  //双循环判断p是否是q的子列
    {
        while(p!=NULL)
        {
    /***修改代码******/
            if(q->data == p->data)
            {
                count++;
            }
            else
                p = p->next;
  /***********************/  
        }
        if(p != NULL)
            q = q->next;
        else
            break;
    }
    if(count == n)
        printf("yes\n");
    else
        printf("no\n");
    destroy(p);
    destroy(q);
    return 0;
}

Input

一个整数m,表示A序列的长度m。

m个数表示A序列中的m个数据元素。

一个整数n,表示B序列的长度n。

n个数表示B序列中的n个数据元素。

Output

yes 或者 no

Sample Input

9
12 13 14 15 6 71 18 19 10
5
15 6 71 18 19

Sample Output

yes

#include<stdio.h>
#include<malloc.h>
struct node             //定义结构体
{
    int data;
    struct node *next;
};
struct node *creat(int n)
{
    struct node *head,*p,*q; //head是头节点,p指向新开辟的节点,q指向已连接的上一个节点
    head=(struct node *)malloc(sizeof(struct node));//给head开辟一个节点
    q = head;  //q节点连接到head上
    while(n--)  //开辟n个新节点,逐个连到链表上
    {
        p=(struct node *)malloc(sizeof(struct node));
        scanf("%d",&p->data);//p该连在q后边吧?
        q->next = p;
        q = p;

    }
    q->next = NULL;//链表结束
    return head;
}
void destroy(struct node *head)
{
 struct node *p;
 while(head!=NULL)
 {
  p=head->next;
  delete(head);
  head=p;
 }
}

int main()//建两条链表p,q
{
    int m,n,count=0;
    struct node *head1,*head2,*p,*q;
    scanf("%d",&m);
    head1 = creat(m);
    scanf("%d",&n);
    head2 = creat(n);
    q=head2->next;
    p = head1->next;
    while(q != NULL)  //双循环判断p是否是q的子列
    {
        while(p!=NULL)
        {
    /***修改代码******/
            if(q->data == p->data)
            {
                count++;
                break;
            }
            else
                p = p->next;
  /***********************/  
        }
        if(p != NULL)
            q = q->next;
        else
            break;
    }
    if(count == n)
        printf("yes\n");
    else
        printf("no\n");
    destroy(p);
    destroy(q);
    return 0;
}


### 回答1: 可以使用动态规划的方法来解决该问题。 假设原始的线性表为 $a$,$a_i$ 表示第 $i$ 个元素的值。定义 $dp_i$ 表示以 $a_i$ 结尾的最长递增子序列的长度。则可以得到以下状态转移方程: $$dp_i=\max_{0\le j<i}(dp_j+1),\quad a_j<a_i$$ 其中,$0\le j<i$ 表示要求在 $a_j<a_i$ 的前提下,找到所有的 $dp_j$ 的最大值。也就是说,只有当 $a_j<a_i$ 时,才能将 $a_j$ 加入到以 $a_i$ 结尾的最长递增子序列中。 最终的答案即为 $dp$ 数组中的最大值。 下面是一个 Python 代码的示例: ```python def find_lis(a): n = len(a) dp = [1] * n for i in range(1, n): for j in range(i): if a[j] < a[i]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) a = [1, 3, 2, 4, 5, 6, 7, 8] print(find_lis(a)) # Output: 7 ``` 在这个示例中,线性表 $a$ 中的最长递增子序列为 $[1, 2, 4, 5, 6, 7, 8]$,其长度为 $7$。 ### 回答2: 查找线性表中最长递增子序列的方法有多种,下面介绍一种常用的动态规划思路。 首先,定义一个长度为n的数组dp,其中dp[i]表示以第i个元素结尾的最长递增子序列的长度。对于任意1<=i<=n,初始时dp[i]的值都为1,表示以第i个元素自身为长度为1的递增子序列。 然后,从数组第2个元素开始,依次遍历所有元素。对于当前遍历到的元素nums[i],我们需要在前面的元素中找到比它小的数,并更新dp[i]为最大的dp[j]+1,其中j满足nums[j]<nums[i]。 最后,遍历dp数组,找到最大的dp[i]即为最长递增子序列的长度。倒序遍历dp数组,从最大的dp[i]对应的元素nums[i]开始反向查找,直到找到dp[i]==1为止,这样就找到了最长递增子序列。 具体步骤如下: 1. 初始化dp数组,所有元素置为1。 2. 遍历从2到n的每个元素nums[i]: 2.1. 内部再遍历从1到i-1的每个元素nums[j]: 2.1.1. 若nums[j]<nums[i],更新dp[i]为最大的dp[j]+1。 3. 找到dp数组中的最大值maxLen。 4. 从dp中找到maxLen对应的元素nums[i],向前寻找直到找到dp[i]==1。 5. 输出最长递增子序列。 以上是一种常用的动态规划方法,时间复杂度为O(n^2)。还有一种时间复杂度为O(nlogn)的方法,利用二分查找和辅助数组来实现,但相对更为复杂。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值