C++博客-夜幻梦回-文章分类-Hdu

hdu 3415 Max Sum of Max-K-sub-sequence ——单调队列

火碳黑 — Sat, 20 Nov 2010 05:17:00 GMT

单调队列:存放一个单调序列。用于对于一个给定大小为k的区间，求出区间内的最值问题。

队列可以双端出队，队列可以看成一半是存放过期的值，一半是存放对未来有用的值。

以a[i]结尾的k窗口内的最大值f[i] = Max{a[i-k+1] ... a[i]};f[i+1] = Max{a[i+1-k+1]... a[i+1]};

所以在求f[i+1]时，可以利用求f[i]时筛选出对f[i+1]有效的值。

在求f[i]时，在区间[i-k+1 + 1,i]内的值才对f[i+1]有效（可以在队列从头开始判断下标来删除一些过期值）。而在这个有效区间内，比a[i]小的数对f[i+1]不是必要的，所以只需要存放a[i]，比a[i]大的数对f[i+1]可能是必要的，就不能删除（通过从队尾开始删除比a[i]小的值)。删除好后的队列存放的是一个从大到小的有效值序列，那f[i]就是队头元素了。

Max Sum of Max-K-sub-sequence

Problem Description

Given a circle sequence A[1],A[2],A[3]......A[n]. Circle sequence means the left neighbour of A[1] is A[n] , and the right neighbour of A[n] is A[1].
Now your job is to calculate the max sum of a Max-K-sub-sequence. Max-K-sub-sequence means a continuous non-empty sub-sequence which length not exceed K.

Input

The first line of the input contains an integer T(1<=T<=100) which means the number of test cases.
Then T lines follow, each line starts with two integers N , K(1<=N<=100000 , 1<=K<=N), then N integers followed(all the integers are between -1000 and 1000).

Output

For each test case, you should output a line contains three integers, the Max Sum in the sequence, the start position of the sub-sequence, the end position of the sub-sequence. If there are more than one result, output the minimum start position, if still more than one , output the minimum length of them.

Sample Input

4
6 3
6 -1 2 -6 5 -5
6 4
6 -1 2 -6 5 -5
6 3
-1 2 -6 5 -5 6
6 6
-1 -1 -1 -1 -1 -1

Sample Output

7 1 3
7 1 3
7 6 2
-1 1 1
题意：给定构成圆环的序列和一个k窗口，求(最大的不超过k长度的最大字段和) 且 (子段和长度取长度最小的)。

#include <iostream>
#define maxn 200010
int num[maxn], que[maxn], sum[maxn], ans[maxn];
int main()
{ 
    int t, n, k, m, i, j, a, b, c, p, max, ksum, len;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &n, &k);
        m = n;
        for (i = 1; i <= n; i++)
        {
            scanf("%d", &num[i]);
        }
        for (j = 1; j < k; j++, i++)//构成 n - 1, n, 1, 2, , k - 1
        {
            num[i] = num[j];
        }
        n = i;
        for (sum[0] = num[0] = 0, i = 1; i < n; i++)
        {
            sum[i] = sum[i-1] + num[i];
        }
        a = b = 0;
        que[b++] = 0;//开始有个值是0,队列里存放的是有效和sum的下标 
        for (i = 1; i < n; i++)
        {
            for (; a < b && que[a] < i - k; a++);//删除过期的值，i-k限定了最大可以取k长度 
            ans[i] = que[a];//对于i结尾的k窗口，f[i] = sum[i]-sum[que[a]] 
            for (; a < b && sum[que[b-1]] >= sum[i]; b--);//删除无效值 
            que[b++] = i; 
        }
        for (i = 1, max = -230000000; i < n; i++)
        {
            ksum = sum[i] - sum[ans[i]];
            if (ksum > max)
            {
                max = ksum;
                p = i;
                len = i - ans[i];
            }
            else if (ksum == max && len > i - ans[i])
            {
                p = i;
                len = i - ans[i];
            }
        }
        c = ans[p] + 1;
        if (c > m)
        {
            c -= m;
        }
        if (p > m)
        {
            p -= m;
        }
        printf("%d %d %d\n", max, c, p);
    }
    system("pause");
    return 0;
}

火碳黑 2010-11-20 13:17 发表评论

hdu 3356

火碳黑 — Mon, 19 Apr 2010 02:20:00 GMT

Air Strike

Problem Description

General Gee is the commander of a military base. He has just received alarming news from one of his spies: the enemy's preparing an air missile strike. The base contains two magnetic towers. When activated and given sufficient power, each of the magnetic towers creates a powerful horizontal magnetic disk. If any missile passes through this disk it deflects away from the base.
Although those towers seem to be an excellent air defense method, there is a problem: The area of the disk generated by a tower is proportional to the amount of energy it receives. The base has enough power plants to generate a certain amount of energy, which has to be divided among those two towers. That means that the total area of the two disks generated from the towers should not exceed the total energy generated by the power plants. Fortunately, the spy was able to know the exact target co-ordinates of the incoming missiles and he reported them to General Gee. The General needs your help in distributing the energy on the two magnetic towers to minimize the number of missiles that will not get deflected by the magnetic towers and therefore will hit the base. You may assume the following:
   1. The towers have different heights and therefore there are no problems associated with the magnetic disks interfering with each other.
   2. A missile will deflect if it passes through the magnetic disk of a tower or even if it just touches its boundary.
   3. A missile hitting a tower (landing exactly on its location) will deflect, even if the tower is not given any energy.
   4. All incoming missiles will go down simultaneously at the exact instant; therefore, there will not be any time available to redistribute the energy amongst the two towers during the strike.

Input

Input consists of several test cases. Each test case is specified on N+2 lines. The first line contains an integer (1 <= N <= 1, 000) representing the number of missiles. The second line contains 5 real numbers X₁, Y₁, X₂, Y₂ and T: (X₁, Y₁) is the coordinates of the first tower, (X₂, Y₂) is the coordinates of the second tower and (0 <= T) is the total amount of energy generated from the power plants (the total area of the two magnetic disks). Each line of the remaining N lines contains two real numbers representing the landing coordinates of a missile.
The absolute value of all the given real numbers is less than or equal to 100 and may include a decimal point followed by up to 3 digits. Any two consecutive numbers on the same line are separated by one or more white-space characters. Zero or more blank lines may appear between test cases.
The last line of the input file is made of a single zero.

Output

For each test case, print the following line:
k. M
Where k is the test case number (starting at one,) and M is the minimum number of missiles that will NOT be deflected in the best distribution of energy among the two towers. Use π = 3.141.
Note: There is a blank space before M.

Sample Input

6
-3 0 3 0 40.833
-1 4
-2 2.5
1 2
5 2
-4 0
-3 -1
2
0 0 1 1 0
0 0
1 1
0

Sample Output

1. 2
2. 0

#include<stdio.h>
#include<stdlib.h>
#define maxn 1000
#define PI 3.141
const double inf = 0.00001;
double d1[maxn], d2[maxn];
double dis(double x1, double y1, double x2, double y2)
{
    return 1.0 * (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
int main()
{
    int n, i, j, ans, sum, k = 0;
    double r1, r2, r3, r4, r;
    double x1, y1, x2, y2, x, y;
    while (scanf("%d", &n), n)
    {
        scanf("%lf%lf%lf%lf%lf", &x1, &y1, &x2, &y2, &r);
        r = 1.0 * r / PI;
        for (i = 0; i < n; i++)
        {
            scanf("%lf%lf", &x, &y);
            d1[i] = dis(x, y, x1, y1);
            d2[i] = dis(x, y, x2, y2);
        }
        for (i = 0, ans = n; i < n; i++)
        {
            r1 = d1[i];
            if (r1 <= r)//枚举一个点和其中一个塔的距离r1,则剩下的磁波距离为r2
            {
                r2 = r - r1;
                for (j = 0, sum = 0; j < n; j++)
                {
                    if (d1[j] <= r1)
                    {
                        sum++;
                    }
                    else if (d2[j] <= r2)
                    {
                        sum++;
                    }
                }
                if (ans > n - sum)
                {
                    ans = n - sum;
                }
            }
            r2 = d2[i];
            if (r2 <= r)
            {
                r1 = r - r2;
                for (j = 0, sum = 0; j < n; j++)
                {
                    if (d1[j] <= r1)
                    {
                        sum++;
                    }
                    else if (d2[j] <= r2)
                    {
                        sum++;
                    }
                }
                if (ans > n - sum)
                {
                    ans = n - sum;
                }
            }
            
        }
        k++;
        printf("%d. %d\n", k, ans);
    }
    return 0;
}

火碳黑 2010-04-19 10:20 发表评论

hdu 3355 广搜

火碳黑 — Sat, 17 Apr 2010 13:02:00 GMT

Hop — Don’t Walk!

Problem Description

KERMIT THE FROG is a classic video game with a simple control and objective but requires a good deal of thinking.
You control an animated frog that can walk and hop, in both forward and backward directions. The frog stands in a space between an otherwise a contiguous line of tiles. Each tile is painted black on one side, and white on the other. The frog can walk (forward, or backward) over an adjacent tile (in front or behind him.)
When the frog walks over a tile, the tile slides to the space where the frog was standing. For example, in the adjacent figure, the frog has two tiles behind him, and three in front. We’ll use the notation BWFBBW to refer to this situation where F refers to the space (where the frog is standing,) B is a tile with its black face showing, while W is a tile with its white face showing. The forward direction is from left to right. If the frog were to walk forward, the resulting situation is BWBFBW. Similar behavior when the frog walks backward, the tile behind the frog slides to where the frog was standing. The frog can also hop over the tiles. The frog can hop over an adjacent tile landing on the tile next to it. For example, if the frog was to hop backward, it would land on the first (left-most) tile, and the tile would jump to the space where the frog was standing. In addition, the tile would flip sides. For example, hopping backward in the figure would result in the situation: FWWBBW. We challenge you to write a program to determine the minimum number of moves (walks or hops) to transform one tile configuration into another.

Input

Your program will be tested on one or more test cases. Each test case is specified on a single line that specifies string S representing the initial tile arrangement. S is a non-empty string and no longer than 100 characters and is made of the letters ’B’, ’W’, and exactly one ’F’. The last line of the input file has one or more ’-’ (minus) characters.

Output

For each test case, print the following line:
k. M
Where k is the test case number (starting at one,) and M is the minimum number of moves needed to transform the given arrangement to an arrangement that has no white tile(s) between any of its black tiles . The frog can be anywhere. M is -1 if the problem cannot be solved in less than 10 moves.
Note: There is a blank space before M.

Sample Input

WWBBFBW
WWFBWBW
FWBBWBW
---

Sample Output

1. 0
2. 1
3. 2

题意：青蛙可向前或向后走一步，走后，青蛙所在位置的砖滑到青蛙没跳前的位置。青蛙也可以向前跳或向后跳，跳一次能跳过2个砖，

青蛙所在位置的砖翻转后滑到青蛙没跳前的位置。求青蛙在十个动作之内，使任意两个黑砖之间没白砖的最小步数。


#include
#include
#define maxn 300000
int ans, len;
char state[maxn][100];
char step[maxn], f[maxn];
int check(int depth)
{
    int i, j, x, y;
    for (i = 0, j = len - 1, x = y = -1; i < len; i++, j--)
    {
        if (state[depth][i] == 'B' && x == -1)
        {
            x = i;
        }
        if (state[depth][j] == 'B' && y == -1)
        {
            y = j;
        }
    }
    if (x != -1 && y != -1)
    {
        for (i = x + 1; i < y; i++)
        {
            if (state[depth][i] == 'W')
            {
                return 0;
            }
        }
    }
    return 1;
}
void swap(int depth, int i, int j)
{
    state[depth][i] ^= state[depth][j];
    state[depth][j] ^= state[depth][i];
    state[depth][i] ^= state[depth][j];
}
void hopf(int depth, int i)
{
    swap(depth, i, i + 2);
    state[depth][i] = (state[depth][i] == 'B') ? 'W' : 'B' ;
}
void hopb(int depth, int i)
{
    swap(depth, i, i - 2);
    state[depth][i] = (state[depth][i] == 'B') ? 'W' : 'B' ;
}
void bfs()
{
    int head = 0, tial = 1, h;
    if (check(0))
    {
        ans = 0;
        return;
    }
    while (head < tial)
    {
        if (step[head] >= 9)
        {
            return;
        }
        h = f[head];
        if (h + 1 < len)
        {        
            strcpy(state[tial], state[head]);
            swap(tial, h, h + 1);
            step[tial] = step[head] + 1;
            f[tial] = h + 1;
            if (check(tial))
            {
                ans = step[tial];
                return;
            }
            tial++;
        }
        if (h - 1 >= 0)
        {
            strcpy(state[tial], state[head]);
            swap(tial, h, h - 1);
            step[tial] = step[head] + 1;
            f[tial] = h - 1;
            if (check(tial))
            {
                ans = step[tial];
                return;
            }
            tial++;
        }
        if (h + 2 < len)
        {
            strcpy(state[tial], state[head]);
            hopf(tial, h);
            step[tial] = step[head] + 1;
            f[tial] = h + 2;
            if (check(tial))
            {
                ans = step[tial];
                return;
            }
            tial++;
        }
        if (h - 2 >= 0)
        {
            strcpy(state[tial], state[head]);
            hopb(tial, h);
            step[tial] = step[head] + 1;
            f[tial] = h - 2;
            if (check(tial))
            {
                ans = step[tial];
                return;
            }
            tial++;
        }
        head++;
    }
}
int main()
{
    int i, j, k = 0;
    char s[100];
    while (scanf("%s", s), s[0] != '-')
    {
        k++;
        ans = 10;
        for (i = 0; (state[0][i] = s[i]) != 0; i++)
        {
            if (s[i] == 'F')
            {
                j = i;
            }
        }
        len = i;
        strcpy(state[0], s);
        step[0] = 0;
        f[0] = j;
        bfs();        
        printf("%d. %d\n", k, ans < 10 ? ans : -1);
    }
}

火碳黑 2010-04-17 21:02 发表评论