摆动序列(DP)

 算法训练 摆动序列  
时间限制:1.0s   内存限制:512.0MB
      
问题描述
  如果一个序列满足下面的性质,我们就将它称为摆动序列:
  1. 序列中的所有数都是不大于k的正整数;
  2. 序列中至少有两个数。
  3. 序列中的数两两不相等;
  4. 如果第i – 1个数比第i – 2个数大,则第i个数比第i – 2个数小;如果第i – 1个数比第i – 2个数小,则第i个数比第i – 2个数大。
  比如,当k = 3时,有下面几个这样的序列:
  1 2
  1 3
  2 1
  2 1 3
  2 3
  2 3 1
  3 1
  3 2
  一共有8种,给定k,请求出满足上面要求的序列的个数。
输入格式
  输入包含了一个整数k。(k<=20)
输出格式
  输出一个整数,表示满足要求的序列个数。
样例输入
3
样例输出
8
感觉这题不能说啊,,说起来都是泪啊!!!@@#%@%


还是上代码吧:

第一个是别人做的

#include <stdio.h>
#include <math.h>
  
int main()
{
    int k;
    scanf("%d", &k);
    printf("%d", (int)(pow(2, k) - k - 1) * 2);
    return 0;
}


下面是我的:

# include <stdio.h>
# include <memory.h>
int a[11111];
int c[11111];
int count=0;
int n;
int max;
int min;
int main()
{
    int i,j,temp;
    
    scanf("%d", &n);
    max = n;
    min = 1;
    int k,h;
    int cnt;
    int t[1111];
    for (i=1; i<=n; i++)
        c[i] = i;
    for (i=1; i<=n; i++)
    {
        a[1]=i;
        for (j=1; j<=n; j++)
        {
            if (i==j)
                continue;
            if (a[1]==max || a[1]==min)
            {
                count++;
                continue;
            }
            
            a[2] = j;
            cnt = 2;
            k=1;
            h=1;
            count++;
            memset(t, 0, sizeof(t));
            while (cnt<=n)
            {           
                if ((a[cnt-1]==max || a[cnt-1]==min) && h==1)
                    break;
                if ((a[cnt-1]==max || a[cnt-1]==min) && h!=1)           
                {
                    cnt = t[--h];
                    t[h]=0;
                    if (a[cnt-2]>a[cnt-1])
                    {
                        a[cnt] = a[cnt]+1;
                        if (a[cnt] != max)
                            t[h++] = cnt;
                        count++;
                    }   
                    else
                        if (a[cnt-2]<a[cnt-1])
                        {
                            a[cnt] = a[cnt]-1;
                            if (a[cnt] != min)
                                t[h++] = cnt;
                            count++;
                        }   
                }
                if ((a[cnt-1]==max || a[cnt-1]==min) && h==1)
                    break;  
                if (a[cnt-1] > a[cnt] && a[cnt-1]!=max)
                {
                    count++;
                    a[cnt+1] = a[cnt-1]+1;
                    if (a[cnt+1] != max)
                        t[h++] = cnt+1;
                    cnt++;
                }
                else if (a[cnt-1] < a[cnt] && a[cnt-1]!=min)
                {
                    count++;
                    a[cnt+1] = a[cnt-1]-1;
                    if (a[cnt+1] != min)
                        t[h++] = cnt+1;
                    cnt++;
                }
                if (a[cnt-1]==max || a[cnt-1]==min)
                {
                    if (h > 1)
                    {
                        cnt = t[--h];
                        t[h]=0;
                        if (a[cnt-2]>a[cnt-1])
                        {
                            a[cnt] = a[cnt]+1;
                            if (a[cnt] != max)
                                t[h++] = cnt;
                            count++;
                        }   
                        else
                            if (a[cnt-2]<a[cnt-1])
                            {
                                a[cnt] = a[cnt]-1;
                                if (a[cnt] != min)
                                    t[h++] = cnt;
                                count++;
                            }   
                    }   
                }
            }
        }
    }   
    printf("%d", count);
    
    return 0;
}



<think>首先,用户的问题是关于如何使用C++实现摆动序列。我需要参考提供的引用内容来构建我的回答。从引用中: -引用[1]展示了摆动排序(Wiggle Sort)的C++代码,它确保数组元素交替大于和小于前一个元素。-引用[2]是关于摆动序列(WiggleSequence)的LeetCode问题,它计算最长的摆动序列长度。-引用[3]也讨论摆动序列,描述为从序列中删除元素以保持摆动顺序的最长子序列。 -引用[4]定义了一个特定的摆动序列问题,涉及序列中数字的特定模式。 -引用[5]提供了一些链接,但内容不直接可用。用户说“摆动序列”,在上下文中,可能指的是摆动序列问题,如引用[2]和[3]所述,即寻找最长的摆动序列。引用[1]是关于摆动排序,这是一个不同的概念,但相关。 摆动序列(WiggleSequence):一个序列如果连续数字之间的差严格交替在正负之间,则称为摆动序列。例如,[1,7,4,9,2,5]是一个摆动序列,因为差是+6,-3, +5,-7, +3。摆动排序(Wiggle Sort):重新排列数组,使得nums[0] <=nums[1]>= nums[2] <=nums[3]>= ...或类似。用户的问题是关于“摆动序列”,所以我应该关注摆动序列的实现,如引用[2]和[3]。在引用[2]中,有一个C++代码示例,用于计算摆动序列的最长子序列长度: ```cppclass Solution{ public:int wiggleMaxLength(vector<int>&nums){if (nums.size() <=1) returnnums.size();int curdiff =0;int prediff =0;int out=1;for(inti =0;i <nums.size() -1; i++) {curdiff =nums[i+1]- nums[i];if((prediff >=0&& curdiff <0) ||(prediff <=0&& curdiff >0)) {out++;prediff= curdiff;}}returnout;}}; ```引用[3]也讨论了类似的内容。 引用[4]定义了一个不同的摆动序列,但用户可能指的是常见的摆动序列问题。所以,我应该解释摆动序列的概念,并提供C++实现来找到最长的摆动序列长度。现在,关于系统指令: -所有行内数学表达式使用 $...$,例如$x^2$。 -独立公式使用$$...$$并单独成段。 -LaTeX语法正确。-使用中文回答。-生成相关问题。 -在引用的段落末尾添加引用标识,例如[^1]。回答结构:1.清晰、逐步解决问题。2.保证真实可靠。 步骤: 1.介绍摆动序列。2.解释算法。 3.提供C++代码。 4.解释代码。 5.添加引用。6.生成相关问题。数学表达式:摆动序列涉及差值的交替,所以可能有不等式,如$a_i -a_{i-1}>0$和$a_i- a_{i-1} <0$交替。引用:我需要引用提供的引用内容。例如,引用[2]提供了代码,所以我应该在代码后添加 [^2]。 相关问题:基于内容生成几个相关问题。最终回答结构:-开头:解释摆动序列。-算法描述:使用贪心算法或动态规划。 -代码实现:提供C++代码。-代码解释。 -相关问题。</think>### 如何使用C++实现摆动序列 摆动序列(Wiggle Sequence)是指一个序列中连续元素之间的差值严格交替为正负(即序列元素交替上升和下降)。例如,序列 $[1,7,4,9,2,5]$ 中,差值为 $+6, -3, +5, -7, +3$,满足摆动条件。摆动序列问题通常涉及寻找原始序列中最长的摆动序列长度(即通过删除部分元素但不改变剩余元素顺序得到的最长摆动序列)。本回答将基于贪心算法实现摆动序列的长度计算,并提供完整的C++代码示例。 #### 摆动序列算法描述 摆动序列的核心是检测序列中“峰”和“谷”的交替变化。算法步骤如下: 1. **初始化**:处理边界情况(如序列长度小于等于1)。 2. **遍历序列**:对于每个元素,计算当前差值 $curdiff = nums[i] - nums[i-1]$。 3. **检查摆动条件**:如果当前差值与前一差值符号相反(例如,前一差值 $\geq 0$ 且当前差值 $< 0$,或前一差值 $\leq 0$ 且当前差值 $> 0$),则序列长度增加。 4. **更新状态**:记录前一差值,用于下一次比较。 5. **输出结果**:返回摆动序列的长度。 贪心算法的时间复杂度为 $O(n)$,空间复杂度为 $O(1)$,高效且易于实现[^2][^3]。 #### C++代码实现 以下代码实现了摆动序列的最长子序列长度计算,基于引用[2]和引用[3]中的方法: ```cpp #include <iostream> #include <vector> using namespace std; int wiggleMaxLength(vector<int>& nums) { int n = nums.size(); // 处理序列长度小于等于1的情况 if (n <= 1) { return n; } int prediff = 0; // 前一差值,初始化为0以处理起始点 int curdiff = 0; // 当前差值 int length = 1; // 摆动序列长度,初始化为1(至少一个元素) // 遍历序列,计算差值并检查摆动条件 for (int i = 0; i < n - 1; i++) { curdiff = nums[i + 1] - nums[i]; // 计算当前差值 // 检查差值符号是否交替:前一差值非正且当前正,或前一非负且当前负 if ((prediff >= 0 && curdiff < 0) || (prediff <= 0 && curdiff > 0)) { length++; // 满足摆动条件,增加长度 prediff = curdiff; // 更新前一差值(只在摆动时更新,避免平坦区干扰) } } return length; } int main() { // 示例测试 vector<int> nums = {1, 7, 4, 9, 2, 5}; cout << "原始序列: "; for (int num : nums) { cout << num << " "; } cout << endl; int result = wiggleMaxLength(nums); cout << "最长摆动序列长度: " << result << endl; // 输出应为6 return 0; } ``` #### 代码解释 - **初始化**:`prediff` 初始为0,确保第一个有效差值被捕获;`length` 初始为1,因为单个元素被视为摆动序列。 - **遍历逻辑**:循环从索引0开始到倒数第二个元素,计算 `curdiff`。摆动条件 `(prediff >= 0 && curdiff < 0) || (prediff <= 0 && curdiff > 0)` 确保差值符号交替(例如,从正到负或负到正)。 - **更新 `prediff`**:只在满足摆动条件时更新,避免平坦区(如连续相同值)影响长度计数。 - **示例输出**:对于输入 `[1,7,4,9,2,5]`,输出为6,因为整个序列摆动序列[^3]。 - **测试建议**:可修改 `main` 函数测试其他序列,如 `[1,17,5,10,13,15]` 输出应为4。 此实现基于LeetCode问题376的解法,高效可靠[^2][^3]。 #### 注意事项 - **摆动序列 vs. 摆动排序**:摆动序列关注子序列长度(如本代码),而摆动排序(如引用[1])是重新排列数组使元素交替大小,两者不同。 - **边界处理**:序列包含重复值时,算法能正确处理(平坦区不增加长度)。 - **数学基础**:摆动序列要求序列中任意三个连续元素满足不等式 $(a_{i-1} - a_{i-2}) \times (a_i - a_{i-1}) < 0$,表示差值符号变化[^4]。 如果您需要实现其他变体(如生成所有摆动序列),请提供更多细节。
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值