Uva 1609 Feel Good

题面：给出长度为n的数列，然后算出其区间和乘区间最小数所能得到的最大值，并且输出区间

样例输入：

6

3 1 6 4 5 2

样例输出：

60

3 5

原题链接：https://vjudge.net/problem/UVA-1619

---

分析：

这里有两种算法，一种是O(nlogn)的，用st表+递归，另一种是O(n)的，用单调栈。

容易知道对于数列中的每一个数作为相应区间最小值时，虽然这个相应区间不一定唯一的，但是这个最大区间和一定是唯一的。

举个栗子：

对于数列{0, 0, 0, 0, 0}来说，我们不管是选择哪一个元素作为区间最小值，其相应的答案区间都有多种可能，但最大区间和肯定都是0（你选取第一个0作为区间最小值， 那区间可以是[1, 1]，[1, 2]，[1, 3]等等，但是区间和最大值肯定都是0）。

我们看原题的话就会发现原题说明是关于这个区间的输出，我们输出其中合法的任何一个就行了。

但是！但是！其实这是在坑你！表面上是spj，实际上并不是spj！对于每一个给定的数据，其输出的区间也必须也是要跟他给的一毛一样才行orz，具体的潜规则我也不是很清楚，反正用单调栈才能AC，不过本着真理至上的原则，还是两个算法都讲一遍。

================

st表+递归解法

这种做法是枚举区间，然后通过st表O(1)找出区间的最小值，配合前辍和能直接计算出一个可能答案。

那怎么枚举区间呢？

先说下，st表保存的应该是区间最小值的下标 。

比较直观的一点就是当我们选取这个数列的最小值作为区间的最小值的时候，这个区间[1, n]肯定是合法的，设这个最小值的位置为k，那么我们可以知道[1, k-1]， [k+1, n]这两个区间是另外两个该被枚举的区间，然后找出这两个区间最小值的位置，又能将区间再次分割。。。每次所划分的区间所对应的区间最小值所在的位置都是不一样的，通过这个递归过程，如此一来，我们就得到了一个O(n)枚举区间的方法，之所以这个算法是O(nlogn)只是因为建st表要O(nlogn)罢了，其他操作要么O(n)要么O(1)的，只可惜实际上这道题不是spj，这种方法跟单调栈的做法虽然都是对的，但是所得区间不一定一样，不然数据水点的话说不定也能过(x)。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;

 const int N = 1e5 + ;
 int Logn[N];
 long long a[N];
 long long sum[N]; //前辍和
 int st[N][]; //记录区间[l, r]中最小元素下标的st表
 long long ans; //最终答案
 int L, R; //最终答案区间

 void pre() {
     Logn[] = ;
     for (int i = ; i < N; i++)
         Logn[i] = Logn[i / ] + ;
 }

 void Build_st(int n) //建立st表
 {
     int logn = Logn[n];
     for(int j=; j<=logn ;j++)
         for (int i = ; i + ( << j) -  <= n; i++) {
             if (a[st[i][j - ]] < a[st[i + ( << (j - ))][j - ]])
                 st[i][j] = st[i][j - ];
             else st[i][j] = st[i + ( << (j - ))][j - ];
         }
 }

 int Query(int l, int r)
 {
     int s = Logn[r - l + ];

     if (a[st[l][s]] < a[st[r +  - ( << s)][s]]) return st[l][s];
     else return st[r +  - ( << s)][s];
 }

 void solve(int l, int r) //递归处理
 {
     if (l > r) return;

     int m = Query(l, r);
     long long res = (sum[r] - sum[l-]) * a[m];
     if (res > ans) {
         ans = res;
         L = l;
         R = r;
     }

     solve(l, m - );
     solve(m + , r);
 }

 int main()
 {
     //freopen("data.txt", "r", stdin);
     //freopen("WA.txt", "w", stdout);
     ios::sync_with_stdio(false);
     pre();
     int n;
     while (cin >> n) {
         ans = -;

         for (int i = ; i <= n; i++) {
             cin >> a[i];
             sum[i] = a[i] + sum[i - ];
             st[i][] = i;
         }

         Build_st(n);
         solve(, n);
         cout << ans << endl;
         cout << L << " " << R << endl;
         cout << endl;
     }

     return ;
 }

================

单调栈解法

单调栈的话做法就很单纯了，用数组l[i], r[i]分别保存元素a[i]作为区间最小值时所能延伸到的最左端跟最右端，用单调栈扫描两次这两个数组的值就能全部出来了，实际写代码的时候博主写惯了不小心写成了单调队列，不过操作都一样的。。。

 #include<iostream>
 #include<algorithm>
 #include<queue>
 using namespace std;

 typedef long long ll;
 const int Maxn = 1e5 + ;
 ll a[Maxn];
 ll l[Maxn];
 ll r[Maxn];
 ll sum[Maxn];

 int main()
 {
     int n;
     bool first = true;
     while (cin >> n) {
         if (first) first = false;
         else cout << endl;

         for (int i = ; i <= n; i++) {
             cin >> a[i];
             sum[i] = sum[i - ] + a[i];
         }

         deque <ll > rq, lq;
         for (int i = ; i <= n; i++) {
             while (!rq.empty() && a[rq.back()] > a[i]) {
                 r[rq.back()] = i - ;
                 rq.pop_back();
             }

             rq.push_back(i);
         }
         while (!rq.empty()) {
             r[rq.front()] = n;
             rq.pop_front();
         }

         for (int i = n; i >= ; i--) {
             while (!lq.empty() && a[lq.back()] > a[i]) {
                 l[lq.back()] = i + ;
                 lq.pop_back();
             }

             lq.push_back(i);
         }
         while (!lq.empty()) {
             l[lq.front()] = ;
             lq.pop_front();
         }

         ll ans = ;
         ll ans_l = , ans_r = ;

         for(int i=; i<=n ;i++)
             if ((sum[r[i]] - sum[l[i] - ]) * a[i] > ans) {
                 ans = (sum[r[i]] - sum[l[i] - ]) * a[i];
                 ans_l = l[i];
                 ans_r = r[i];
             }

         cout << ans << endl;
         cout << ans_l << " " << ans_r << endl;
     }

     return ;
 }