C++博客-ArcTan-文章分类-Topcoder

SRM 500 DIV2 500PT（模拟）

wangs — Sun, 22 Jul 2012 02:10:00 GMT

Problem Statement

NOTE: This problem statement contains images that may not display properly if viewed outside of the applet.

We had a rectangular grid that consisted of W x H square cells. We placed a robot on one of the cells. The robot then followed the rules given below.

Initially, the robot is facing east.
The robot moves in steps. In each step it moves to the adjacent cell in the direction it currently faces.
The robot may not leave the grid.
The robot may not visit the same cell twice. (This also means that it may not reenter the starting cell.)
If a step forward does not cause the robot to break the above rules, the robot takes the step.
Otherwise, the robot rotates 90 degrees to the left (counter-clockwise) and checks whether a step forward still breaks the above rules. If not, the robot takes the step and continues executing this program (still rotated in the new direction).
If the rotation left did not help, the robot terminates the execution of this program.
We can also terminate the execution of the program manually, at any moment.

For example, the following seven images show a series of moves made by the robot in a 12 x 11 board:

We forgot the dimensions of the grid and the original (x,y) coordinates of the cell on which the robot was originally placed, but we do remember its movement. You are given a vector moves. This sequence of positive integers shall be interpreted as follows: The robot performed moves[0] steps eastwards, turned left, performed moves[1] steps northwards, turned left, and so on. After performing the last sequence of steps, the robot stopped. (Either it detected that it should terminate, or we stopped it manually.) We are not sure if the sequence of moves is valid. If the sequence of moves is impossible, return -1. Else, return the minimum area of a grid in which the sequence of moves is possible. (I.e., the return value is the smallest possible value of the product of W and H.).

Definition

Class:	RotatingBot
Method:	minArea
Parameters:	vector
Returns:	int
Method signature:	int minArea(vector moves)
(be sure your method is public)

Constraints

moves will contain between 1 and 50 elements, inclusive.

Each element of moves will be between 1 and 50, inclusive.

Examples

{15}

Returns: 16

The smallest valid board is a 16x1 board, with the robot starting on the west end of the board.

{3,10}

Returns: 44

The smallest solution is to place the robot into the southwest corner of a 4 x 11 board.

{1,1,1,1}

Returns: -1

This sequence of moves is not possible because the robot would return to its initial location which is forbidden.

{9,5,11,10,11,4,10}

Returns: 132

These moves match the image from the problem statement.

{12,1,27,14,27,12,26,11,25,10,24,9,23,8,22,7,21,6,20,5,19,4,18,3,17,2,16,1,15}

Returns: 420

{8,6,6,1}

Returns: -1

{8,6,6}

Returns: 63

{5,4,5,3,3}

Returns: 30

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

模拟题目，直接按照给定序列遍历，如果遇到不合法的情况return -1。设定四个方向，mw,me,mn,ms，东北西南，初始为上下界。然后依次找到范围。
初始点(100,100)。
最后的面积为(me-mw+1)*(ms-mn+1)

没有考虑完全啊，思维还是不严谨不完整，就WA了一组数据，昨晚做就悲剧了！！！！
我是弱菜，继续努力！

不错的模拟题目，需要考虑的东西很多！

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <algorithm>
#define min(x,y) (x
#define max(x,y) (x>y?x:y)
#define swap(t,x,y) (t=x,x=y,y=t)
#define clr(list) memset(list,0,sizeof(list))

using namespace std;
bool maps[205][205];
int go[4][2]={{1,0},{0,-1},{-1,0},{0,1}};
class RotatingBot{
public:
    int minArea(vector <int> moves){
        int n=moves.size();
        int me=1000,mw=0,mn=0,ms=1000;
        int tmp;
        int dir;
        int x,y,xx,yy;
        clr(maps);
        maps[100][100]=1;
        x=100,y=100,dir=0;
        for (int i=0;i<n ;i++)
        {
            tmp=moves[i];
            for (int j=0;j<tmp;j++)
            {
                xx=x+go[dir][0];yy=y+go[dir][1];
                if (maps[xx][yy] || (xx<mw || xx>me || yy<mn || yy>ms))
                    return -1;
                else
                {
                    maps[xx][yy]=1;
                    x=xx;y=yy;
                }
            }
            xx=x+go[dir][0];yy=y+go[dir][1];
            if (!maps[xx][yy])
            {
                if (dir==0)
                    if (me==1000)
                        me=x;
                    else
                        if (x<me && i<n-1)
                            return -1;
                if (dir==1)
                    if (mn==0)
                        mn=y;
                    else if (y>mn && i<n-1)
                        return -1;
                if (dir==2)       //这里WA了testing 5 & 6
                    if (mw==0 && x<=100)
                        mw=x;
                    else
                        if (x>mw && i<n-1)
                            return -1;
                if (dir==3)    //最后栽在这里了
                    if (ms==1000 && y>=100)
                        ms=y;
                    else if ((y<ms || y<100) && i<n-1)
                        return -1;
            }
            dir=(dir+1) % 4;
        }
     //   return mw;
        if (mw==0)
            mw=100;
        if (mn==0)
            mn=100;
        if (ms==1000)
            ms=100;
        return (me-mw+1)*(ms-mn+1);
    }
};

wangs 2012-07-22 10:10 发表评论

SRM550 DIV2 250PT（字符串水题）

wangs — Sun, 22 Jul 2012 02:02:00 GMT

Problem Statement

We have a string originalWord. Each character of originalWord is either 'a' or 'b'. Timmy claims that he can convert it to finalWord using exactly k moves. In each move, he can either change a single 'a' to a 'b', or change a single 'b' to an 'a'.

You are given the strings originalWord and finalWord, and the int k. Determine whether Timmy may be telling the truth. If there is a possible sequence of exactly k moves that will turn originalWord into finalWord, return "POSSIBLE" (quotes for clarity). Otherwise, return "IMPOSSIBLE".

Definition

Class:	EasyConversionMachine
Method:	isItPossible
Parameters:	string, string, int
Returns:	string
Method signature:	string isItPossible(string originalWord, string finalWord, int k)
(be sure your method is public)

Notes

Timmy may change the same letter multiple times. Each time counts as a different move.

Constraints

originalWord will contain between 1 and 50 characters, inclusive.

finalWord and originalWord will contain the same number of characters.

Each character in originalWord and finalWord will be 'a' or 'b'.

k will be between 1 and 100, inclusive.

Examples

"aababba"

"bbbbbbb"

Returns: "IMPOSSIBLE"

It is not possible to reach finalWord in fewer than 4 moves.

"aabb"

"aabb"

Returns: "IMPOSSIBLE"

The number of moves must be exactly k=1.

"aaaaabaa"

"bbbbbabb"

Returns: "POSSIBLE"

Use each move to change each of the letters once.

"aaa"

"bab"

Returns: "POSSIBLE"

The following sequence of 4 moves does the job:
aaa -> baa -> bab -> aab -> bab

"aababbabaa"

"abbbbaabab"

Returns: "IMPOSSIBLE"

字符串水题！

249.23PT！！！

wangs 2012-07-22 10:02 发表评论

SRM 150 DIV 2 1000pt（模拟）

wangs — Sun, 15 Jul 2012 14:01:00 GMT

Problem Statement

You are given a rectangular map in which each space is marked with one of three characters: '.' (open), 'B' (a brick), or '#' (an indestructible block). Walls made of indestructible blocks surround the field on all sides, but are not shown on the map. A ball is bouncing around this map, destroying bricks, and your task is determine how long it takes the ball to destroy all the bricks.

The top left space of the map is always open, and this is where the ball begins. More specifically, the ball begins at time 0 in the middle of the top edge of this space (see the diagram in Example 0). The ball is traveling diagonally down and to the right at a speed of half a meter per second vertically, and half a meter per second horizontally. Each space is 1 meter square, so the ball crosses half a space vertically and half a space horizontally each second.

Whenever the ball strikes the edge of an obstacle--either a brick or an indestructible block--it bounces off at an angle perpendicular to its incoming path. The ball will never hit two obstacles simultaneously. Whenever the ball bounces off a brick, the brick is destroyed and removed from the map.

Your method should return the time at which the last brick is destroyed. If one or more bricks will never be destroyed, return -1.

Definition

Class:	BrickByBrick
Method:	timeToClear
Parameters:	vector
Returns:	int
Method signature:	int timeToClear(vector map)
(be sure your method is public)

Constraints

map contains between 1 and 15 elements, inclusive.

All elements of map contain the same number of characters (between 1 and 15, inclusive).

All elements of map contain only the characters '.', 'B', and '#'.

The top left corner of map (that is, the first character of the first element) is '.'.

map contains at least one 'B'.

Examples

{ ".B",   "BB" }

Returns: 6

The following diagram illustrates the path of the ball.

     __0________     | / \ |     |     |/   \|     |     3  .  1  B  |     |\   /|\    |     | \ / | \   |     |--2--|--6--|     |     |     |     |     |     |     |  B  |  B  |     |     |     |     |_____|_____|

The ball begins at point 0, traveling down and to the right. It bounces off the first brick at time 1, and off the second brick at time 2. At time 3, it bounces off the left wall, and at time 4 it bounces off the upper wall at the same place it started. At time 6, the ball destroys the third and final brick, so the method returns 6.

{ ".BB",   "BBB",   "BBB" }

Returns: -1

The ball will never hit the brick in the bottom right corner.

{ "......B",   "###.###",   "B.....B" }

Returns: 35

{ "..BBB...",   ".#BB..#.",   "B.#B.B..",   "B.B.....",   "##.B.B#.",   "#BB.#.B.",   "B..B.BB.",   "#..BB..B",   ".B....#." }

Returns: -1

{ ".BB..BBB.B...",   "B.B...B..BB..",   "#B...B#B.....",   "B#B.B##...##B",   "BB.B#.B##B.B#",   "B.B#.BBB.BB#B",   "B#BBB##.#B#B.",   "B#BB.BBB#BB.#" }

Returns: 3912

{ ".BBBBBBBBBBBBBB",   "##############B",   "BBBBBBBBBBBBBBB",   "B##############",   "BBBBBBBBBBBBBBB",   "##############B",   "BBBBBBBBBBBBBBB",   "B##############",   "BBBBBBBBBBBBBBB",   "##############B",   "BBBBBBBBBBBBBBB",   "B##############",   "BBBBBBBBBBBBBBB",   "##############B",   "BBBBBBBBBBBBBBB" }

Returns: 31753

题意：就像是那个啥游戏，看了那个图就挺好理解的了。
注意方向变换。

写了好久好久啊，
404PT：

#include<stdio.h>
#include<fstream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

class BrickByBrick
{
public:
    int timeToClear(vector <string> map)
    {
        int time=0;
        int bricks=0;
        int impactTime=0;

        float x,y,dirX,dirY,newX,newY;

        for (int i=0; i<map.size(); i++)
        {
            map[i].insert(0,sizeof(char),'#');
            map[i].push_back('#');
        }

        string s;
        for (int i=0; i<map[0].length(); i++)
            s.push_back('#');

        map.insert(map.begin(),s);
        map.push_back(s);

        for (int i=0; i<map.size(); i++)
            bricks+=count(map[i].begin(),map[i].end(),'B');

        x=1.5;
        y=1;
        dirX=dirY=0.5;

        while (bricks && impactTime <1000)
        {
            impactTime++;
            x+=dirX;
            y+=dirY;

            if (dirX==0.5 && dirY==0.5)
            {
                if ((int)x==x)
                {
                    newX=(int)x;
                    newY=(int)y;
                }
                else if ((int)y==y)
                {
                    newX=(int)x;
                    newY=(int)y;
                }
            }
            if (dirX==-0.5 && dirY==-0.5)
            {
                if ((int)x==x)
                {
                    newX=(int)x-1;
                    newY=(int)y;
                }
                else if ((int)y==y)
                {
                    newX=(int)x;
                    newY=(int)y-1;
                }
            }
            if (dirX==-0.5 && dirY==0.5)
            {
                if ((int)x==x)
                {
                    newX=(int)x-1;
                    newY=(int)y;
                }
                else if ((int)y==y)
                {
                    newX=(int)x;
                    newY=(int)y;
                }
            }
            if (dirX==0.5 && dirY==-0.5)
            {
                if ((int)x==x)
                {
                    newX=(int)x;
                    newY=(int)y;
                }
                else if ((int)y==y)
                {
                    newX=(int)x;
                    newY=(int)y-1;
                }
            }
            if (map[newY][newX]!='.')
            {
                if ((int)x==x)
                {
                    if (dirX==0.5 && dirY==0.5)
                    {
                        dirX=-0.5;
                        dirY=0.5;
                    }
                    else if (dirX==-0.5 && dirY==-0.5)
                    {
                        dirX=0.5;
                        dirY=-0.5;
                    }
                    else if (dirX==-0.5 && dirY==0.5)
                    {
                        dirX=0.5;
                        dirY=0.5;
                    }
                    else if (dirX==0.5 && dirY==-0.5)
                    {
                        dirX=-0.5;
                        dirY=-0.5;
                    }
                }
                if ((int)y==y)
                {
                    if (dirX==0.5 && dirY==0.5)
                    {
                        dirX=0.5;
                        dirY=-0.5;
                    }
                    else if (dirX==0.5 && dirY==-0.5)
                    {
                        dirX=0.5;
                        dirY=0.5;
                    }
                    else if (dirX==-0.5 && dirY==0.5)
                    {
                        dirX=-0.5;
                        dirY=-0.5;
                    }
                    else if (dirX==-0.5 && dirY==-0.5)
                    {
                        dirX=-0.5;
                        dirY=0.5;
                    }
                }
            }
            if (map[newY][newX]=='B')
            {
                map[newY][newX]='.';
                time+=impactTime;
                impactTime=0;
                bricks--;
            }
        }
        if (impactTime==1000)
            return -1;
        return time;
    }
};

wangs 2012-07-15 22:01 发表评论

SRM 150 DIV 2 500pt（thinking && 数论）

wangs — Sun, 15 Jul 2012 13:54:00 GMT

Problem Statement

The digits 3 and 9 share an interesting property. If you take any multiple of 3 and sum its digits, you get another multiple of 3. For example, 118*3 = 354 and 3+5+4 = 12, which is a multiple of 3. Similarly, if you take any multiple of 9 and sum its digits, you get another multiple of 9. For example, 75*9 = 675 and 6+7+5 = 18, which is a multiple of 9. Call any digit for which this property holds interesting, except for 0 and 1, for which the property holds trivially.

A digit that is interesting in one base is not necessarily interesting in another base. For example, 3 is interesting in base 10 but uninteresting in base 5. Given an int base, your task is to return all the interesting digits for that base in increasing order. To determine whether a particular digit is interesting or not, you need not consider all multiples of the digit. You can be certain that, if the property holds for all multiples of the digit with fewer than four digits, then it also holds for multiples with more digits. For example, in base 10, you would not need to consider any multiples greater than 999.

Definition

Class:	InterestingDigits
Method:	digits
Parameters:	int
Returns:	vector
Method signature:	vector digits(int base)
(be sure your method is public)

Notes

When base is greater than 10, digits may have a numeric value greater than 9. Because integers are displayed in base 10 by default, do not be alarmed when such digits appear on your screen as more than one decimal digit. For example, one of the interesting digits in base 16 is 15.

Constraints

base is between 3 and 30, inclusive.

Examples

Returns: { 3,  9 }

All other candidate digits fail for base=10. For example, 2 and 5 both fail on 100, for which 1+0+0=1. Similarly, 4 and 8 both fail on 216, for which 2+1+6=9, and 6 and 7 both fail for 126, for which 1+2+6=9.

Returns: { 2 }

Returns: { 2,  4,  8 }

Returns: { 5,  25 }

Returns: { 29 }

题意给定base进制数里，找出里面所有的特别的数x,对于x的倍数kx，它的每一位的和还是x的倍数。
比如base=10，则x=3和9。

这个应该是小学时候就记得的结论了，专门算3和9的，哈哈。

结论：base %x==1是充要条件。
证明：
               a=a1*base^0+a2*base^1+a3*base^2,对于任何a都可以这样分解
      因为 base % x=1，则base^k %x==1。则上式化简为
               a==a1+a2+a3+.. (mod x)
         反之，也可得base %x==1

440PT啊，小小犹豫了下哦。直接枚举了x验证啊。

其实就是求base-1的因子，如果base很大地话，是不能这样去枚举的。因子分解哦，又是经典问题啊。

#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;

class InterestingDigits{
public:
    vector <int> digits(int base){
        int a[31];
        int n=0;
        int i=2;
        while (i<base){
            if (base % i==1)
                a[n++]=i;
            i++;
        }
        vector <int> ans(n);
        for (i=0;i<n;i++)
            ans[i]=a[i];
        return ans;
    }
};

wangs 2012-07-15 21:54 发表评论

SRM 150 DIV 2 250pt（队列）

wangs — Sun, 15 Jul 2012 13:37:00 GMT

Problem Statement

When a widget breaks, it is sent to the widget repair shop, which is capable of repairing at most numPerDay widgets per day. Given a record of the number of widgets that arrive at the shop each morning, your task is to determine how many days the shop must operate to repair all the widgets, not counting any days the shop spends entirely idle.

For example, suppose the shop is capable of repairing at most 8 widgets per day, and over a stretch of 5 days, it receives 10, 0, 0, 4, and 20 widgets, respectively. The shop would operate on days 1 and 2, sit idle on day 3, and operate again on days 4 through 7. In total, the shop would operate for 6 days to repair all the widgets.

Create a class WidgetRepairs containing a method days that takes a sequence of arrival counts arrivals (of type vector ) and an int numPerDay, and calculates the number of days of operation.

Definition

Class:	WidgetRepairs
Method:	days
Parameters:	vector , int
Returns:	int
Method signature:	int days(vector arrivals, int numPerDay)
(be sure your method is public)

Constraints

arrivals contains between 1 and 20 elements, inclusive.

Each element of arrivals is between 0 and 100, inclusive.

numPerDay is between 1 and 50, inclusive.

Examples

{ 10, 0, 0, 4, 20 }

Returns: 6

The example above.

{ 0, 0, 0 }

Returns: 0

{ 100, 100 }

Returns: 20

{ 27, 0, 0, 0, 0, 9 }

Returns: 4

{ 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6 }

Returns: 15

直接遍历就行，每天完成不了的留到第二天做。最后没有完成的延迟到后面做。
求的的做的天数是多少，没有做的那天不用算。

228PT，速度还是慢了点。

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
using namespace std;

class WidgetRepairs{
public:
    int days(vector <int> arrivals, int numPerDay){
        int n=arrivals.size();
        int now=0;
        int i=0;
        int tot=0;
        while (i<n || now) //这里可以优化一下，如果i==n就不用循环了，剩下的需要完成的天数为(now-1)/numPerDay+1。
        {
            if (i<n)
                now+=arrivals[i];
            if (now>0)   //第一次这里理解错了，以后要把细节搞清楚啊。。。
                tot++;
            now=now>numPerDay?now-numPerDay:0;
            i++;
        }
        return tot;
    }
};

wangs 2012-07-15 21:37 发表评论

SRM549 DIVⅡ 1000pt（AOV网拓扑排序）

wangs — Tue, 10 Jul 2012 01:59:00 GMT

Problem Statement

The Order of the Hats is a magical organization. One of their duties is to teach students how to cast spells. There are N spells numbered from 0 to N-1. As an aid for the students, the teachers have prepared a spell chart. The chart lists suggestions on the order in which to study the spells. (This is explained in more detail below.)

Recently, some changelings broke into the Order's spell archive and messed up the spell chart. You are given a String[] spellChart containing the new, messed-up state of the spell chart. Each character of each element of spellChart is either 'Y' or 'N'. The students will come to study soon. They will interpret the chart in the following way: If spellChart[i][j] is 'Y' then spell i must be learned before spell j.

As the chart is now messed up, it may be impossible to learn all the spells in the chart because of cycles in the requirements. Your task is to repair the given chart. Determine the minimum number of changes needed to remove all the cycles in the requirements. In a single change, you may either change some character spellChart[i][j] from 'Y' to 'N', or change some character from 'N' to 'Y'.

Definition

Class:	OrderOfTheHats
Method:	minChanged
Parameters:	String[]
Returns:	int
Method signature:	int minChanged(String[] spellChart)
(be sure your method is public)

Constraints

spellChart will contain between 1 and 20 elements, inclusive.

Each element of spellChart will contain N characters, where N is the number of elements in spellChart.

Each character in each element of spellChart will be either 'Y' or 'N'.

Examples

{"Y"}

Returns: 1

This spell chart contains a spell that should be learned before itself. The students would never be able to learn such a spell. We can remove this cyclic dependency by changing the 'Y' to 'N'.

{"NYN",  "NNY",  "NNN"}

Returns: 0

This spell chart is already OK.

{"NYN",  "NNY",  "YNN"}

Returns: 1

Changing any single 'Y' to a 'N' will fix this spell chart.

{"NYYYYYY",  "YNYYYYY",  "YYNYYYY",  "YYYNYYY",  "YYYYNYY",  "YYYYYNY",  "YYYYYYN"}

Returns: 21

{"NNNY",  "YNYN",  "YNNN",  "YYYN"}

Returns: 1

{"YYYYYNNYYYNYNNNNYNNY",  "NYNNNYYNNYNYYYNYYYYY",  "NNYNNNYYNNNNNNYYYYNY",  "YYNYNYYNNYYYNYNNNYYY",  "NYYNNYNYNYNNNNYYYNYN",  "NNNNNYYNYNNYYYYNYYYN",  "YNYNYYNNNYNNNNNYNNYY",  "NYYYYNYNYNNYNNYNNNNY",  "YYYYNYYNNYYYNNYNNYNY",  "YYYYYYNYNYNYNNNNNNYN",  "NNYYYYYNNNYNNNYNNNNY",  "YYNNNYNYYNYYNYYNYNYN",  "NNYNYYNYYNYYNYNYNYYN",  "YNYNYYNYNNNYNYNYYNYY",  "NNYNNNYYYYYYYYYYYNYY",  "YYYYYNYYNYYYYYNNYNNN",  "NYYYYYYYYNNNNNYYNNYN",  "YNNYNNNYYNYYYNYNYYYY",  "YYNNYNYYYNYYNNNYYNNY",  "NNYNYNYYYNYYNYNNYNNN"}

Returns: 79

{"YYNYNN",  "YNYNNY",  "YYYYNN",  "NNNYNN",  "NNNYNN",  "YNYNYN"}

Returns: 5

{"NNNNNNNNNN",  "NNNNNNNNNN",  "NNNYNNYNNN",  "NNNYNNYNNN",  "NNNYNNYNNN",  "NNNNNNNNNN",  "NNYYYYYYNN",  "NNYNNNNYNN",  "NNNYYYYNNN",  "NNNNNNNNNN"}

Returns: 6

题意：给定一张N*N的map，N个顶点的图，map[i][j]=='Y'，，否则。求最小的转换Y或者N，使该图没有环！

思路：怎么做呢？thinking

wangs 2012-07-10 09:59 发表评论

SRM549 DIVⅡ 500pt(最大匹配)

wangs — Tue, 10 Jul 2012 01:14:00 GMT

Problem Statement

The Order of All Things Pointy and Magical has commissioned the creation of some new wizard hats. A wizard hat is created by taking two cones: a decorative top cone, and a warm and fluffy bottom cone. To assemble the hat, both cones are first placed onto a table, so that their bases are horizontal and their apexes point upwards. The top cone is then lifted and placed onto the bottom cone. The base of the top cone has to remain horizontal, and the apex of the top cone must be strictly above the apex of the bottom cone.

Not every pair of cones can be used to create a wizard hat. A wizard hat is only produced if the following two criteria are both met:

The apex of the top cone must be strictly above the apex of the bottom cone. I.e., when the top cone is placed on top of the bottom cone and released, their apexes must not touch.
Some part of the bottom cone must remain visible to form the brim of the hat. (Otherwise, the hat would look like a simple cone, not like a wizard hat!)

You have several top cones and several bottom cones of various sizes. Each cone can be described by its height (the distance between the apex and the base) and by the radius of its base. The top cones you have are described by topHeight and topRadius: for each valid i, you have one top cone with height topHeight[i] and radius topRadius[i]. The bottom cones you have are described by bottomHeight and bottomRadius in the same way.

Your task is to determine the maximum number of wizard hats you can make using each of the available top and bottom cones at most once.

Definition

Class:	PointyWizardHats
Method:	getNumHats
Parameters:	vector , vector , vector , vector
Returns:	int
Method signature:	int getNumHats(vector topHeight, vector topRadius, vector bottomHeight, vector bottomRadius)
(be sure your method is public)

Constraints

topHeight and topRadius will contain the same number of elements.

bottomHeight and bottomRadius will contain the same number of elements.

topHeight will contain between 1 and 50 elements, inclusive.

topRadius will contain between 1 and 50 elements, inclusive.

bottomHeight will contain between 1 and 50 elements, inclusive.

bottomRadius will contain between 1 and 50 elements, inclusive.

Each element of topHeight, topRadius, bottomHeight, and bottomRadius will be between 1 and 10,000, inclusive.

Examples

{30}

{3}

{3}

{30}

Returns: 1

The top and bottom cone can be used together to make a wizard hat.

{4,4}

{4,3}

{5,12}

{5,4}

Returns: 1

The only way to produce a wizard hat is to use the top cone 1 (height 4, radius 3) and the bottom cone 0 (height 5, radius 5).

{3}

{3}

{1,1}

{2,4}

Returns: 1

{10,10}

{2,5}

{2,9}

{3,6}

Returns: 2

{3,4,5}

{5,4,3}

{3,4,5}

{3,8,5}

Returns: 2

{1,2,3,4,5}

{2,3,4,5,6}

{2,3,4,5,6}

{1,2,3,4,5}

Returns: 0

{123,214,232,323,342,343}

{123,123,232,123,323,434}

{545,322,123,545,777,999}

{323,443,123,656,767,888}

Returns: 5

{999,999,999,10000,10000,10000}

{10000,10000,10000,1,2,3}

{2324,2323,234,5454,323,232}

{1,2,3222,434,5454,23}

Returns: 3

题意：一个hat由上面top cone和下面的bottom cone组成。给定上面cone的高和底半径，topHeigh[],topRadius[]下面cone的bottomHeight[],bottomRadius[]
         上下两个cone组成hat需要满足条件：
                  1：The apex of the top cone must be strictly above the apex of the bottom cone. I.e., when the top cone is placed on top of the bottom cone and released, their apexes must not touch.
                  2：Some part of the bottom cone must remain visible to form the brim of the hat. (Otherwise, the hat would look like a simple cone, not like a wizard hat!)

思路：求二分图的最大匹配，模版题。
         topcone 和bottomcone满足的条件是：topR

错误提交了一次，尼玛！！！犹豫不决不敢coding不行呀！！

175.22pt

#include<stdio.h>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
bool map[55][55];
int result[55];
bool state[55];
int n,m;
class PointyWizardHats{
public:
    int find(int x)
    {
        int i;
        for (i=0;i<m ;i++ )
        {
            if (map[x][i]==1 && !state[i])
            {
                state[i]=1;
                if (result[i]==-1 || find(result[i]))
                {
                    result[i]=x;
                    return 1;
                }
            }
        }
        return 0;
    }
    bool can(int x1,int y1,int x2,int y2) //这个条件我犹豫了半天，thinking不够啊！
    {
        if (y2*x1>y1*x2 && y2>y1)
            return 1;
        return 0;
    }
    int getNumHats(vector <int> topHeight, vector <int> topRadius, vector <int> bottomHeight, vector <int> bottomRadius){

        int i,j;
        int ans;
        n=topHeight.size();
        m=bottomHeight.size();
        memset(map,0,sizeof(map));
        for (j=0;j<m;j++)
            result[j]=-1;    //这里之前全部设置的0啊啊啊！！！
        for (i=0;i<n;i++)
            for (j=0;j<m;j++)
                if (can(topHeight[i],topRadius[i],bottomHeight[j],bottomRadius[j]))
                    map[i][j]=1;
        ans=0;
        for (i=0;i<n;i++)
        {
            memset(state,0,sizeof(state));
            if (find(i))
                ans++;
        }
        return ans;
    }
};

wangs 2012-07-10 09:14 发表评论

SRM549 DIVⅡ 250pt (概率想法题)

wangs — Tue, 10 Jul 2012 01:03:00 GMT

Problem Statement

A magician has invited you to play a game. For this game, the magician uses a special table. On the table there are three spots in a row. The spots are labeled 0, 1, and 2, in order. He places three hats onto the table, so that each hat covers one of the spots. He then takes a ball and places it under one of the hats. The hats are not transparent, so you cannot see the ball while it is under a hat. Next, the magician shuffles the hats by repeatedly swapping two adjacent hats. Each swap is done by sliding the hats along the table, never showing you the ball. Once the magician finishes swapping the hats, you have to guess the spot where the ball is.

You are given a string hats which describes the contents of the hats in the beginning of the game. The i-th character of hats is 'o' if the ball was initially on the spot i. Otherwise, the i-th character of hats is '.' (a period).

You are also given a int numSwaps. Assume that the magician swapped the hat that contained the ball exactly numSwaps times. Please remember that in our version of the game the magician always swaps two adjacent hats. Also, note that the total number of swaps in the game may be larger than numSwaps, because the magician may sometimes swap two hats that don't contain the ball.

Assume that the magician chose the swaps he makes uniformly at random. That is, in each turn with probability 50% he swapped the hats on spots 0 and 1, and with probability 50% he swapped the hats on spots 1 and 2. Return the number of the spot that is most likely to contain the ball at the end of the game. If multiple spots are tied for the largest probability, return the smallest one of them.

Definition

Class:	BallAndHats
Method:	getHat
Parameters:	string, int
Returns:	int
Method signature:	int getHat(string hats, int numSwaps)
(be sure your method is public)

Notes

Two hats are adjacent if their spots differ by 1.

Constraints

hats will contain exactly three characters.

hats will contain exactly one 'o' character.

hats will contain exactly two '.' characters.

numSwaps will be between 0 and 1000, inclusive.

Examples

".o."

Returns: 0

The spots 0 and 2 are equally likely to contain the ball after the hat that contains it is swapped once. We return the smallest spot number, which is 0.

"..o"

Returns: 2

The ball does not change spots when 0 swaps are performed; therefore, the ball must be at spot 2.

"o.."

Returns: 1

"..o"

Returns: 0

"o.."

Returns: 1

题意：给三个帽子，一个帽子下面有气球。一次SWAP可将相邻的两个帽子交换。每次SWAP的概率一样的，0和1，1和2交换的概率都是50%。给出初始状态，总共有numSwaps次SWAP了带气球的帽子。问最后气球在哪个位置的概率最大，如果有几个位置，则求最小的位置。

思路：想法题！numSwaps奇偶性讨论分析

176.5pt thinking速度太低，多分析分析，锻炼思维哦！

#include<string>
using namespace std;
class BallAndHats{
public:
    int getHat(string hats, int numSwaps){
        int i=0;
        while (hats[i]!='o')    i++;
        if (numSwaps==0)
            return i;
        numSwaps%=2;
        if (i==0 && numSwaps==0)
            return 0;
        if (i==1 && numSwaps==1)
            return 0;
        if (i==2 && numSwaps==0)
            return 0;
        return 1;
    }
};

wangs 2012-07-10 09:03 发表评论

SRM548 DIVⅡ－500PT（二分答案OR贪心）

wangs — Tue, 03 Jul 2012 02:15:00 GMT

二分答案倒是很快就想到了的，刚开始没有想好怎么验证check()。后面就跪在这里了。。。。tree.height>=1啊。。。
毛哥给的办法是行的，贪心。ORZ，ORZ，我没写呀。。。。
爆零。。其实应该果断提交的吧？

#include<stdio.h>
#include<string.h>
#include<vector>
using namespace std;
int h[55],n;
int max(int x,int y)
{
    return x>y?x:y;
}
bool check(int x)
{
        int last,now,i;
        last=max(h[0]-x,1);
        for (i=1;i<n;i++){
            now=h[i];
            if (now+x<=last)
                return false;
            last=max(last+1,now-x);
        }
        return true;
}
class KingdomAndTrees{
public:

    int minLevel(vector <int> heights){
        int l,r,mid,i;
        n=heights.size();
        for (i=0;i<n;i++)
            h[i]=heights[i];
        l=0;r=0;
        for (i=0;i<n;i++)
            if (h[i]>r)
                r=h[i];
        r=r+n;
        while (l<r){
            mid=(l+r)/2;
            if (check(mid))
                r=mid;
            else
                l=mid+1;
        }
        return r;
    }
};

下次TC要雪耻才行！

wangs 2012-07-03 10:15 发表评论

SRM548 DIVⅡ－250PT（纯水题）

wangs — Tue, 03 Jul 2012 02:09:00 GMT

第二次做TC，没能保住绿色。182.0PT

#include<string.h>
#include<vector>
using namespace std;
int t[51];
class KingdomAndDucks{
public:
    int minDucks(vector <int> duckTypes){
        int n,i,max,m;
        memset(t,0,sizeof(t));
        n=duckTypes.size();
        for (i=0;i<n;i++)
            t[duckTypes[i]]++;
        max=0;m=0;
        for (i=1;i<=50;i++){
            if (t[i]>0)
                m++;
            max=max>t[i]?max:t[i];
        }
        return m*max;
    }
};

就只过了这一个题目，编码速度不行呀，得快快练习起来！

wangs 2012-07-03 10:09 发表评论