周结2020.4.6

这一周还是做的上周的题，不过时间充足了很多，题也做了不少，总结下区间dp解法
区间DP主要是把一个大区间拆分成几个小区间，先求小区间的最优值，然后合并起来求大区间的最优值。
//一般区间DP实现代码
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; i++） //区间长度为1的初始化
dp[i][i] = 0;
for (int len = 2; len <= n; len++) //枚举区间长度
{
for (int i = 1, j = len; j <= n; i++, j++) //区间[i,j]
{
//DP方程实现
}
}
另外这周的cf，打的和之前差不多，dive2的题还是只做了AB两题，并且B题在测试三还超时了，改了改重新交了两次还是超时所以就没接着交，及时止损，掉分太狠了，这次的本想冲下C题，没想到还是卡在B题,dive 3也是只做了AB，C题最后没时间交了，很可惜。并且这次打cf的时候发现题ac后是可以锁上的，后来查了下，早锁加分多。
看一下当时的dive 2的B题
B. Nastya and Door
time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
On February 14 Denis decided to give Valentine to Nastya and did not come up with anything better than to draw a huge red heart on the door of the length k (k≥3). Nastya was very confused by this present, so she decided to break the door, throwing it on the mountains.

Mountains are described by a sequence of heights a1,a2,…,an in order from left to right (k≤n). It is guaranteed that neighboring heights are not equal to each other (that is, ai≠ai+1 for all i from 1 to n−1).

Peaks of mountains on the segment [l,r] (from l to r) are called indexes i such that l<i<r, ai−1ai+1. It is worth noting that the boundary indexes l and r for the segment are not peaks. For example, if n=8 and a=[3,1,4,1,5,9,2,6], then the segment [1,8] has only two peaks (with indexes 3 and 6), and there are no peaks on the segment [3,6].

To break the door, Nastya throws it to a segment [l,l+k−1] of consecutive mountains of length k (1≤l≤n−k+1). When the door touches the peaks of the mountains, it breaks into two parts, after that these parts will continue to fall in different halves and also break into pieces when touching the peaks of the mountains, and so on. Formally, the number of parts that the door will break into will be equal to p+1, where p is the number of peaks on the segment [l,l+k−1].

Nastya wants to break it into as many pieces as possible. Help her choose such a segment of mountains [l,l+k−1] that the number of peaks on it is maximum. If there are several optimal segments, Nastya wants to find one for which the value l is minimal.

Formally, you need to choose a segment of mountains [l,l+k−1] that has the maximum number of peaks. Among all such segments, you need to find the segment that has the minimum possible value l.

Input
The first line contains an integer t (1≤t≤104) — the number of test cases. Then the descriptions of the test cases follow.

The first line of each test case contains two integers n and k (3≤k≤n≤2⋅105) — the number of mountains and the length of the door.

The second line of the input data set contains n integers a1,a2,…,an (0≤ai≤109, ai≠ai+1) — the heights of mountains.

It is guaranteed that the sum of n over all the test cases will not exceed 2⋅105.

Output
For each test case, output two integers t and l — the maximum number of parts that the door can split into, and the left border of the segment of length k that the door should be reset to.
Example
input
5
8 6
1 2 4 1 2 4 1 2
5 3
3 2 3 2 1
10 4
4 3 4 3 2 3 2 1 0 1
15 7
3 7 4 8 2 3 4 5 21 2 3 4 2 1 3
7 5
1 2 3 4 5 6 1
output
3 2
2 2
2 1
3 1
2 3
Note
In the first example, you need to select a segment of mountains from 2 to 7. In this segment, the indexes 3 and 6 are peaks, so the answer is 3 (only 2 peaks, so the door will break into 3 parts). It is not difficult to notice that the mountain segments [1,6] and [3,8] are not suitable since they only have a 1 peak (for the first segment, the 6 index is not a peak, and for the second segment, the 3 index is not a peak).

In the second example, you need to select a segment of mountains from 2 to 4. In this segment, the index 3 is a peak, so the answer is 2 (only 1 peak, so the door will break into 2 parts).

In the third example, you need to select a segment of mountains from 1 to 4. In this segment, the index 3 is a peak, so the answer is 2 (only 1 peak, so the door will break into 2 parts). You can see that on the segments [2,5], [4,7] and [5,8] the number of peaks is also 1, but these segments have a left border greater than the segment [1,4], so they are not the correct answer.

这题的大概意思就有一根棍子倒下，下面有山峰a[j-1]<a[j]&&a[j]>a[j+1]，山峰会把棍子弄断，问最多断成几段，相同的段数，要求靠左为准。
当时的这个b题，一开始没啥思路，还是后来想起用前缀和暴力求解了

#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
int main()
{
    int t;
    int n,k;
    int a[200005],sum[200005];
    cin>>t;
    while(t--)
    {
        memset(a,0,sizeof(a));
        memset(sum,0,sizeof(sum));
        cin>>n>>k;
        int ans=-1,c=n-k+1,d=k-2;
        for(int i=1; i<=n; i++)
            cin>>a[i];
        for(int i=1; i<=c; i++)
        {
            for(int j=i+1,q=1; q<=d; q++,j++)
                if(a[j-1]<a[j]&&a[j]>a[j+1])
                    sum[i]++;
            ans=max(ans,sum[i]);
        }
        for(int j=1; j<=c; j++)
            if(sum[j]==ans)
            {
                cout<<ans+1<<" "<<j<<endl;
                break;
            }

    }
}

dive 3也是只做了AB，C题最后没时间交了，很可惜。