FZU1862(线段树 或者 DP)

Problem 1862 QueryProblem

Accept: 100    Submit: 249
Time Limit: 2000 mSec    Memory Limit : 32768 KB

Problem Description

There
are N numbers (non-negative integers) in a circle. Now your task is
quite simple, just tell me the largest number between L and R.

The Figure 1 is a sample of five integers in a circle. (marked with their index, but not their exact value.)

Figure 1.

The Figure 2,3 show how we count the number.

Figure 2.

Figure 3.

Input

There are no more than 10 test cases;

For each case, the first line contains only one integer N, indicates the size of the circle.

The following one line contains N non-negative integers where Mi
indicates the i-th integers whose index is i. (1 <= N <= 1000, 1
<= i <= N, 0 <= Mi <= 10^9)

Then one line contains Q indicates the number of querys. (1 <= Q <= 10^5)

Then the next Q lines, each line contains only two integers indicate L and R (1 <= L,R <= N)

Output

For each case, please output “Case #index:” in a single line, here index is the case index starts from one.

For each query just output a single line indicates the largest number between L and R.

Output a blank line after each case.

Sample Input

2
3 8
3
1 1
1 2
2 1
1
9
1
1 1

Sample Output

Case #1:
3
8
8

Case #2:
9

Hint

Huge Input, please “scanf” to avoid time limit exceed.

题意:在给定的区间中查询最大的数。当L>R时,R =R +n 来改变R这也是2*n的原因;

方法1:线段树

收获:函数中的num指的是线段树上的编号,而当le == ri时,le 或 ri指的是最低层的编号。

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <map>
#include <set>
using namespace std;

const int INF=0x3f3f3f3f;
const double eps=1e-10;
const double PI=acos(-1.0);
#define maxn 8006
int tre[maxn];
int a[maxn/4];
int n;
void build(int num, int le, int ri)
{
    if(le == ri)
    {
        if(le > n)
            tre[num] = a[le-n];//函数中的num指的是线段树上的编号,而当le == ri时,le 或 ri指的是最低层的编号。
        else
            tre[num] = a[le];
        return;
    }
    int mid = (le + ri)/2;
    build(num*2, le, mid);
    build(num*2+1, mid+1, ri);
    tre[num] = max(tre[num*2], tre[num*2+1]);
}
int query(int num,int le,int ri,int x,int y)
{
    if(x<=le&&y>=ri)
        return tre[num];
    int mid=(le+ri)/2;
    int ans=0;
    if(x<=mid)
        ans=max(ans,query(num*2,le,mid,x,y)); //先查询左边
    if(y>mid)
        ans=max(ans,query(num*2+1,mid+1,ri,x,y)); //再查询右边
    return ans;
}
int main()
{
    int cas = 1;
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        build(1, 1, 2*n);
        int m;
        scanf("%d", &m);
        int a, b;
        printf("Case #%d:\n", cas++);
        for(int j = 0; j < m; j++)
        {
            scanf("%d%d", &a, &b);
            if(b < a)
                b = b + n;
            printf("%d\n", query(1, 1, 2*n, a, b));
        }
        puts("");
    }
}

方法2:DP

收获:对dp有了更多的了解。

dp[i][j]指的是i到j这个区间内保存的最大值。

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <list>
#include <vector>
#include <map>
#include <set>
#define C 0.57721566490153286060651209
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

typedef long long LL;
const int INF=0x3f3f3f3f;
const double eps=1e-10;
const double PI=acos(-1.0);

const int maxn=1000009;
int dp[2020][2020];
int a[2020];
int main()
{
    int n, b;
    int sum=0;
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &b);
            a[i]=a[i+n]=b;
        }
        for(int i = 1; i <=2*n; i++)
        {
             dp[i][i]=a[i];
            for(int j=i+1;j<=2*n;j++)
            {
                if(a[j]>dp[i][j-1])
                    dp[i][j]=a[j];
                else
                    dp[i][j]=dp[i][j-1];
            }
        }
        int m;
        scanf("%d", &m);
        int L, R;
        printf("Case #%d:\n",++sum);
        for(int i=1;i<=m;i++)
        {
            int q,w;
            scanf("%d%d",&q,&w);
            if(w<q)
                w=w+n;
            printf("%d\n",dp[q][w]);
        }
        puts("");
    }
    return 0;
}
时间: 2024-09-30 19:15:42

FZU1862(线段树 或者 DP)的相关文章

【POJ 2750】 Potted Flower(线段树套dp)

[POJ 2750] Potted Flower(线段树套dp) Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 4566   Accepted: 1739 Description The little cat takes over the management of a new park. There is a large circular statue in the center of the park, surrou

BZOJ 1835 基站选址(线段树优化DP)

题目链接:http://61.187.179.132/JudgeOnline/problem.php?id=1835 题意:有N个村庄坐落在一条直线上,第 i(i>1)个村庄距离第1个村庄的距离为Di.需要在这些村庄中建立不超过K个通讯基站,在第i个村庄建立基站的费用为Ci.如果在距离第i个村 庄不超过Si的范围内建立了一个通讯基站,那么就成它被覆盖了.如果第i个村庄没有被覆盖,则需要向他们补偿,费用为Wi.现在的问题是,选择基站的位 置,使得总费用最小. 思路: 另外,程序中的n=n+1,m=

【bzoj3939】[Usaco2015 Feb]Cow Hopscotch 动态开点线段树优化dp

题目描述 Just like humans enjoy playing the game of Hopscotch, Farmer John's cows have invented a variant of the game for themselves to play. Being played by clumsy animals weighing nearly a ton, Cow Hopscotch almost always ends in disaster, but this has

HDU 3016 Man Down 线段树+简单DP

囧,一开始看错题意,后来才发现人是垂直下落的,被附带链接里的Man Down游戏误导了. 那就变成了一个简单的DAG模型动态规划,随意搞就ok了 #include <cstdio> #include <cstring> #include <iostream> #include <map> #include <set> #include <vector> #include <string> #include <queu

Codeforces 833B 线段树优化 dp

Codeforces  833B  The Bakery 题意: n 个数要分成 k 块,每块的价值是其不同数的个数,问价值和最大是多少. tags: dp[i][j]表示前 j 个数分成 i 块的最大权值和,转移: dp[i][j] = max( dp[i-1][k] + val[k+1][j] ) , k是 1~j . 但这个过程其实并不好转移,要利用累加的特点,用线段树进行优化 (感觉我不看题解是想不到的,2333) 大概就是,对于第 i 层,我们假定已经知道了第 i-1 层,也就是求出了

[Poi2010]Monotonicity 2 (线段树优化DP)

题目描述 给出N个正整数a[1..N],再给出K个关系符号(>.<或=)s[1..k].选出一个长度为L的子序列(不要求连续),要求这个子序列的第i项和第i+1项的的大小关系为s[(i-1)mod K+1].求出L的最大值. 输入 第一行两个正整数,分别表示N和K (N, K <= 500,000).第二行给出N个正整数,第i个正整数表示a[i] (a[i] <= 10^6).第三行给出K个空格隔开关系符号(>.<或=),第i个表示s[i]. 输出 一个正整数,表示L的

HDU 4521 小明系列问题——小明序列 (线段树维护DP)

题目地址:HDU 4521 基本思路是DP.找前面数的最大值时能够用线段树来维护节省时间. 因为间隔要大于d. 所以能够用一个队列来延迟更新,来保证每次询问到的都是d个之前的. 代码例如以下: #include <iostream> #include <cstdio> #include <string> #include <cstring> #include <stdlib.h> #include <math.h> #include

bzoj 1835 基站选址(线段树优化Dp)

Description 题意:有N个村庄坐落在一条直线上,第i(i>1)个村庄距离第1个村庄的距离为Di 需要在这些村庄中建立不超过K个通讯基站,在第i个村庄建立基站的费用为Ci 如果在距离第i个村庄不超过Si的范围内建立了一个通讯基站,那么就成它被覆盖了 如果第i个村庄没有被覆盖,则需要向他们补偿,费用为Wi 现在的问题是,选择基站的位置,使得总费用最小. Solution 首先可以想到dp,用dp[i][j]表示前i个村庄建了j个通讯站且第j个建在i处 dp[i][j]=min(dp[k][

hdu 4521 小明系列问题——小明序列(线段树 or DP)

题目链接:hdu 4521 本是 dp 的变形,却能用线段树,感觉好强大. 由于 n 有 10^5,用普通的 dp,算法时间复杂度为 O(n2),肯定会超时.所以用线段树进行优化.线段树维护的是区间内包含某点的最大满足条件的长度,叶子节点以该元素结尾,最长长度.至于相邻两项隔 d 个位置,求 dp[i] 时,我们只把 dp[i - d - 1] 更新至线段树中,然后在这颗线段树中找最大的个数. 具体来说,就是把序列 S 的值 Ai 作为线段树叶子下标,以 Ai 结尾的 LIS 长度(即经典算法里