Algorithm 此任务需要什么算法？

输入：

n

（

int

）和表示汇率的

n

值（

float

） （它们之间不同）具有介于

4

和

5

之间的随机值

输出：计算可使用的最大值数（在 相同的顺序）来表示先上升后下降的曲线

---

e、 十、八大价值观

4.5 4.6 4.3 4.0 4.8 4.4 4.7 4.1

应该输出

5（4.5 4.6 4.8 4.4.1）

---

我的方法

• 如果我尝试连续

  If

  s，我会得到一个符合曲线条件的随机数组，但不是最长的
• 我没有尝试过回溯，因为我对它不太熟悉，但有些事情告诉我，我必须用它计算所有的解，然后选择最长的
• 最后一点：暴力，但因为这是算法设计的任务；我还是不交吧

有更简单/更有效/更快的方法吗

这是我基于Daniel Lemire算法的尝试。它似乎没有考虑位置0、i和n。我确信如果是问题所在，我如何解决它们

for(int i = 0; i<n-1; i++){
            int countp=0;   // count ascending
            int countn=0;   // count descending
            for(int j=0;j<=i;j++){
                    if(currency[j]<currency[j+1]){
                        countp++;
                        System.out.print(j+" ");
                    }
                }
            System.out.print("|| ");
            for(int j=i;j<n-1;j++){
                if(currency[j]>currency[j+1]){
                    countn++;
                    System.out.print(j+" ");
                }
            }
        System.out.println();
        if(countn+countp>maxcount) maxcount=countn+countp;                   
        }

---

for（int i=0；i第一步是了解如何解决相关问题。对于这个问题，有一个是
O（n^2）
尽管是
O（n log n）
。理解这些算法应该会让您找到正确的解决方案。
首先，您希望能够计算从一个点到另一个点的最长单调子序列。（它是增加还是减少对问题影响不大。）要做到这一点，您可以使用动态规划。例如，要解决给定索引0到i的问题，您首先要解决的问题是从0到0（平凡！），然后从0到1，然后从0到2，依此类推，每次记录（在数组中）您的最佳解

例如，这里有一些python代码来计算从索引0到索引i的最长非递减序列。我们使用数组（bbest）来存储从0到i的所有j的从0到j的解：即，从0到j的最长非递减子序列的长度（使用的策略是动态规划）

或等效于Java（根据要求提供）：

它具有二次复杂度。我相信您可以改进此解决方案。此方法中存在大量冗余。例如，为了提高速度，您可能不应该使用未初始化的数组bbest重复调用countasc：它可以计算一次。您可能可以将复杂度降低到O（n log n）还有一些工作。
我不明白“输出”应该是什么。你是怎么找到5的？5个数字是什么？我猜是“5”表示序列4.5、4.6、4.8、4.4、4.1的长度，这是一条先升后降的曲线。你的解决方案是我所理解的最好的解决方案。这是我的尝试，但问题是，当它涉及到位置0、I和n时，它是粗略的。我确信ifs是个问题，但我想不出如何解决它们。感谢代码，但作为一个例子虽然我很费劲，但我无法理解Python语法。我很难理解变量best和thisguy的用途，以及bbest数组的工作原理。你能“翻译”一下吗将其转换为C/C++或Java？非常感谢您的时间！我已经用Java添加了代码。如答案中所述，数组用于动态编程，而best只是用于计算最大值的临时变量。
def countasc(array,i):
  mmin = array[0] # must start with mmin
  mmax= array[i] # must end with mmax
  bbest=[1] # going from 0 to 0 the best we can do is length 1
  for j in range(1,i+1): # j goes from 1 to i
    if(array[j]>mmax):
      bbest.append(0) # can't be used
      continue
    best = 0 # store best result
    for k in range(j-1,-1,-1): # count backward from j-1 to 0
      if(array[k]>array[j]) :
        continue # can't be used
      if(bbest[k]+1>best):
          best = bbest[k]+1
    bbest.append(best)
  return bbest[-1] # return last value of array bbest

int countasc(float[] array,int i) {
    float mmin = array[0];
    float mmax = array[i];
    ArrayList<Integer> bbest= new ArrayList<Integer>();
    bbest.add(1);
    for (int j = 1; j<=i;++j) {
        if(array[j]>mmax){
            bbest.add(0);
            continue;
        }
        int best = 0;
        for(int k = j-1; k>=0;--k) {
            if(array[k]>array[j]) 
                continue;
            if(bbest.get(k).intValue()+1>best)
                best = bbest.get(k).intValue()+1;
        }
        bbest.add(best);
    }
    return bbest.get(bbest.size()-1);
}

Start with S, an empty array
For i an index that goes from 0 to n-1 :
  compute the length of the longest increasing subsequence from 0 to i (see function countasc above)
  compute the length of the longest decreasing subsequence from n-1 to i
  add these two numbers, add the sum to S
return the max of S