1024

原创于 2016-04-21 22:04:11 发布 · 1.8k 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种用于寻找给定序列中所有递增子串的算法实现，通过深度优先搜索(DFS)策略，确保输出符合指定条件的递增子串集合。文章详细展示了如何避免重复元素并控制输出子串的数量。

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

题意：给出一行数，求给定个数的递增子串。

思路：从第一个数开始，找出下一个比它大的数，并在这个数的基础之上，再找出下一个比它大的数，找数的同时记录下子列的SIZE，等到找不到比它大的数的时候，退出此次。然后，从第二个数开始，重复以上步骤，直到最后为止，应当注意的是，要保证子列的输出顺序与样例中的一致，并且还要保证输出的子列个数小于P，属于dfs。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;

int n, p, len, Count;
int num[1001];
bool flag;
struct Tem
{
    int n, pos;
};

Tem tem[1001];

bool check(int from, int cur)
{
    for (int i = from + 1; i < cur; i++)
        if (num[i] == num[cur])
            return false;
    return true;
}
void print(int length)
{
    for (int i = 0; i < length - 1; i++)
        cout << tem[i].n << " ";
    cout << tem[length - 1].n << endl;
}

void dfs(int dep, int pos)
{
    if (Count >= p)return;
    if (dep == len)
    {
        Count++;
        flag = true;
        print(len);
        return;
    }
    for (int i = pos; i<n; i++)
    {
        if ((dep != 0 && tem[dep - 1].n <= num[i]) || dep == 0)
        {
            if (dep == 0 && !check(-1, i))
                continue;
            if (dep != 0 && !check(tem[dep - 1].pos, i))
                continue;
            tem[dep].n = num[i];
            tem[dep].pos = i;
            dfs(dep + 1, i + 1);
        }
    }
    return;
}

int main()
{
    while (cin >> n >> p)
    {
        for (int i = 0; i<n; i++)
            cin >> num[i];
        Count = 0;
        for (int i = 1; i < n; i++)
        {
            flag = false;
            len = i;
            dfs(0, 0);
            if (Count >= p || !flag)break;
        }
        cout << endl;
    }
    return 0;
}