Description

. We are given a figure consisting of only horizontal and vertical line segments. Our goal is to count the number of all different rectangles formed by these segments. As an example, the number of rectangles in the Figures 1 and 2 are 5 and 0 respectively.

There are many intersection points in the figure. An intersection point is a point shared by at least two segments. The input line segments are such that each intersection point comes from the intersection of exactly one horizontal segment and one vertical segment.

Input

. The first line of the input contains a single number M, which is the number of test cases in the file (1 <= M <= 10), and the rest of the file consists of the data of the test cases. Each test case begins with a line containing s (1 <= s <= 100), the number of line segments in the figure. It follows by s lines, each containing x and y coordinates of two end points of a segment respectively. The coordinates are integers in the range of 0 to 1000.

Output

. The output for each test case is the number of all different rectangles in the figure described by the test case. The output for each test case must be written on a separate line.

Sample Input

2

6

0 0 0 20

0 10 25 10

20 10 20 20

0 0 10 0

10 0 10 20

0 20 20 20

3

5 0 5 20

15 5 15 25

0 10 25 10

Sample Output

5

0

解题思路

题意：

题目意思是给你几条边的顶点坐标，让你求出能组成长方形的个数。

思路：

我是这样想的，要组成长方形，首先需要4条边，2横2竖，那么我分别把横边放一起，竖边放一起，再一条一条的去看，如果满足构成长方形的条件就加1。（这个条件我写的似乎有点忒长了，哪位大牛能改一下感激不尽~）源代码如下：

源程序

#include<iostream>

using namespace std;

struct hbian

{

       int x1;

       int y1;

       int x2;

       int y2;

}h[200];

struct sbian

{

       int x1;

       int y1;

       int x2;

       int y2;

}s[200];

int jh,js;

int solve(hbian *h,int jh,sbian *s,int js);

int main()

{

       int Tcase;

       cin>>Tcase;

       while(Tcase--)

       {

              int n,x1,x2,y1,y2;

              cin>>n;

              while(n--)

              {

                     cin>>x1>>y1>>x2>>y2;

                     if(x1==x2)

                     {

                            s[js].x1=x1;

                            s[js].y1=y1>y2?y1:y2;

                            s[js].x2=x2;

                            s[js].y2=y2<y1?y2:y1;

                            js++;

                     }

                     else

                     {

                            h[jh].x1=x1<x2?x1:x2;

                            h[jh].y1=y1;

                            h[jh].x2=x2>x1?x2:x1;

                            h[jh].y2=y2;

                            jh++;

                     }

              }

              cout<<solve(h,jh,s,js)<<endl;

              jh=js=0;

       }

       return 0;

}

int solve(hbian *h,int jh,sbian *s,int js)

{

       int i,j,k,l,sum(0);

       for(i=0;i<jh;i++)

       {

              for(j=0;j<js;j++)

              {

                     for(k=i+1;k<jh;k++)

                     {

                            for(l=j+1;l<js;l++)

                            {

                                   if(s[j].x1>=h[i].x1&&s[j].x1<=h[i].x2&&s[l].x1>=h[i].x1&&s[l].x1<=h[i].x2&&s[j].x1>=h[k].x1&&s[j].x1<=h[k].x2&&s[l].x1>=h[k].x1&&s[l].x1<=h[k].x2&&s[j].y1>=h[i].y1&&s[j].y2<=h[i].y1&&s[l].y1>=h[i].y1&&s[l].y2<=h[i].y1&&s[j].y1>=h[k].y1&&s[j].y2<=h[k].y1&&s[l].y1>=h[k].y1&&s[l].y2<=h[k].y1)

                                          sum++;

                            }

                     }

              }

       }

       return sum;

}

Description

. Each employee of a bureaucracy has a job description - a few paragraphs that describe the responsibilities of the job. The employee's job description, combined with other factors, such as seniority, is used to determine his or her salary.
The Hay Point system frees the Human Resources department from having to make an intelligent judgement as to the value of the employee; the job description is merely scanned for words and phrases that indicate responsibility. In particular, job descriptions that indicate control over a large budget or management over a large number of people yield high Hay Point scores.

You are to implement a simplified Hay Point system. You will be given a Hay Point dictionary and a number of job descriptions. For each job description you are to compute the salary associated with the job, according to the system.

Input

. The first line of input contains 2 positive integers: m <= 1000, the number of words in the Hay Point dictionary, and n <= 100, the number of job descriptions. m lines follow; each contains a word (a string of up to 16 lower-case letters) and a dollar value (a integer number between 0 and 1,000,000). Following the dictionary are the n job descriptions. Each job description consists of one or more lines of text; for your convenience the text has been converted to lower case and has no characters other than letters, numbers, and spaces. Each job description is terminated by a line containing a period.

Output

. For each job description, output the corresponding salary computed as the sum of the Hay Point values for all words that appear in the description. Words that do not appear in the dictionary have a value of 0.

Sample Input

7 2

administer 100000

spending 200000

manage 50000

responsibility 25000

expertise 100

skill 50

money 75000

the incumbent will administer the spending of kindergarden milk money

and exercise responsibility for making change he or she will share

responsibility for the task of managing the money with the assistant

whose skill and expertise shall ensure the successful spending exercise

.

this individual must have the skill to perform a heart transplant and

expertise in rocket science

.

Sample Output

700150

150

解题思路

题意：

先输入两个数字，第一个是接下来要给你关键字的个数及关键字所对应的数字，第二个数字是给你的文字的段数，每段文字结束标志是.要你求文字中包含的关键字所对应数字相加得到的直

思路：

此题比较简单，就是一个一个的比较即可。源程序如下：

源程序

#include<iostream>

#include<string>

using namespace std;

bool bijiao(char *x,char *y);

int main()

{

       int a,b,i(0),s(0),j;

       char c[50];

       cin>>a>>b;

       char (*p)[50]=new char[a][50];

       int *q=new int[a];

       while(i<a)

       {

              cin>>p[i]>>q[i];

              i++;

       }

       i=0;

       while(i<b)

       {

              while(cin>>c)

              {

                     if(c[0]=='.')

                            break;

                     for(j=0;j<a;j++)

                     {

                            if(bijiao(c,p[j]))

                            {

                                   s=s+q[j];

                                   break;

                            }

                     }

              }

              cout<<s<<endl;

              s=0;

              i++;

       }

       return 0;

}

bool bijiao(char *x,char *y)

{

       int b=0;

       int i;

       int len=strlen(x);

       if(len!=strlen(y))

       {

              b++;

       }

       for(i=0;i<len;i++)

       {

              if(len!=strlen(y))

              {

                     b++;

                     break;

              }

              else

              {

                     if(x[i]!=y[i])

                     {

                            b++;

                            break;

                     }

              }

       }

       return b==0;

}

Description

. In millions of newspapers across the United States there is a word game called Jumble. The object of this game is to solve a riddle, but in order to find the letters that appear in the answer it is necessary to unscramble four words. Your task is to write a program that can unscramble words.

Input

. The input contains four parts: 1) a dictionary, which consists of at least one and at most 100 words, one per line; 2) a line containing XXXXXX, which signals the end of the dictionary; 3) one or more scrambled 'words' that you must unscramble, each on a line by itself; and 4) another line containing XXXXXX, which signals the end of the file. All words, including both dictionary words and scrambled words, consist only of lowercase English letters and will be at least one and at most six characters long. (Note that the sentinel XXXXXX contains uppercase X's.) The dictionary is not necessarily in sorted order, but each word in the dictionary is unique.

Output

. For each scrambled word in the input, output an alphabetical list of all dictionary words that can be formed by rearranging the letters in the scrambled word. Each word in this list must appear on a line by itself. If the list is empty (because no dictionary words can be formed), output the line "NOT A VALID WORD" instead. In either case, output a line containing six asterisks to signal the end of the list.

Sample Input

tarp

given

score

refund

only

trap

work

earn

course

pepper

part

XXXXXX

resco

nfudre

aptr

sett

oresuc

XXXXXX

Sample Output

score

******

refund

******

part

tarp

trap

******

NOT A VALID WORD

******

course

******

解题思路

题意：

题目意思是让你查找单词，先让你输入一些单词作为字典里的单词，碰到第一个XXXXXX时结束，下面就输入要求你找的单词，再次碰到XXXXXX时结束输入，在让你找出对应在字典里存在的单词，单词的字母排列可以不同，如果在字典中找到不止一个单词对应时要把他们按字典序进行排序。如果没找到相对应的单词则输出NOT A VALID WORD，每输出对应的一组单词后要输出******。

思路：

把要求找的单词一个一个的和字典中的单词进行比较即可，如果满足条件就用一个2维数组存储该单词，最后对数组进行排序在输出即可。源程序如下：

源程序

#include "stdio.h"

#include "string.h"

#include "stdlib.h"

int zhao(char *x,char y);

bool bijiao(char *x,char *y);

int comp(const void *a,const void *b);

void shuchu(char (*x)[30],char (*y)[30],int q,int w);

int main()

{

       char a[200][30];

       char b[30]="XXXXXX";

       char c[200][30];

       int i(0),j,k(0),l(0);

       while(i<2)

       {

              if(i==0)

              {

                     for(j=0;j<500;j++)

                     {

                            scanf( "%s" , a[ j ] ) ;

                            if(bijiao(a[j],b))

                            {

                                   i++;

                                   break;

                            }

                            k++;

                     }

              }

              else

              {

                     for(j=0;j<500;j++)

                     {

                            scanf( "%s" , c[ j ] ) ;

                            if(bijiao(c[j],b))

                            {

                                   i++;

                                   break;

                            }

                            l++;

                     }

              }

       }

       shuchu(a,c,k,l);

       return 0;

}

int comp(const void *a,const void *b)

{

       return strcmp((char *)a,(char *)b);

}

int zhao(char *x,char y)

{

       int i,a(0);

       int   len = strlen( x ) ;

       for(i=0;i<len;i++)

       {

              if(x[i]==y)

                     a++;

       }

       return a;

}

bool bijiao(char *x,char *y)

{

       int i,b(0);

       int   len = strlen( x ) ;

       int   leny = strlen( y ) ;

       for(i=0;i<len;i++)

       {

              if(len!=leny)

              {

                     b++;

                     break;

              }

              else

              {

                     if(zhao(x,x[i])!=zhao(y,x[i]))

                     {

                            b++;

                            break;

                     }

              }

       }

       return b==0;

}

void shuchu(char (*x)[30],char (*y)[30],int q,int w)

{

       int i,j,k(0),l;

       for(i=0;i<w;i++)

       {

              char (*a)[30]=new char[500][30];

              int   cnt = 0 ;

              k=0;

              for(j=0;j<q;j++)

              {

                     if(bijiao(x[j],y[i]))

                     {

                            strcpy(a[k],x[j]);

                            k++;

                            ++ cnt ;

                     }

              }

              qsort(a,cnt,sizeof(char)*30,comp);

              for(l=0;l<k;l++)

                     printf( "%s\n" , a[l] );

              if(k!=0)

                     printf( "******\n" );

              else

              {

                     printf("NOT A VALID WORD\n");

                     printf( "******\n" );

              }

              delete []a;

       }

}

Description

. In this problem, you will be given one or more integers in English. Your task is to translate these numbers into their integer representation. The numbers can range from negative 999,999,999 to positive 999,999,999. The following is an exhaustive list of English words that your program must account for:
negative, zero, one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, thirty, forty, fifty, sixty, seventy, eighty, ninety, hundred, thousand, million

Input

. The input consists of several instances. Notes on input:

1. Negative numbers will be preceded by the word negative.
2. The word "hundred" is not used when "thousand" could be. For example, 1500 is written "one thousand five hundred", not "fifteen hundred".

The input is terminated by an empty line.

Output

. The answers are expected to be on separate lines with a newline after each.

Sample Input

six

negative seven hundred twenty nine

one million one hundred one

eight hundred fourteen thousand twenty two

Sample Output

6

-729

1000101

814022

解题思路

题意：

此题的题目意思很简单，就是翻译，把英文的数字翻译成阿拉伯数字，如six翻译成6.

思路：

要注意特殊的几个关键词：hundred、thousand、million。因为如果像普通的比如twenty two的话，只要简单的相加。那么碰到关键词我是这么想的，我建立四个int型变量hsum，tsum，msum和sum。看名字可以看出hsum就是用来存碰到关键词hundred时的和，其他依此类推，sum就存没有关键词的和。首先把他们都置为0，当碰到hundred关键词时，hsum=sum*100，同时把sum置为0。碰到关键词thousand时，tsum=(hsum+sum)*1000，同时把hsum和sum都置为0。msum也一样类推。源代码如下：

源程序

#include<iostream>

using namespace std;

char *tiqu(char *x,int y);

int zhuanhuan(char *x);

void solve(char *x);

char A[10][10]={"zero","one","two","three","four","five","six","seven","eight","nine"};

char B[10][10]={"ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"};

char C[8][10]={"twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};

char D[3][10]={"hundred","thousand","million"};

char E[500][10];

int main()

{

       char q[800];

       while(cin.getline(q,800))

       {

              if(strlen(q)==1||strlen(q)==0)

                     continue;

              solve(q);

       }

       return 0;

}

char *tiqu(char *x,int y)

{

       int i,k(0);

       char *t=new char[10];

       for(i=y;x[i]!=' '&&x[i]!='\0';i++)

              t[k++]=x[i];

       t[k]='\0';

       return t;

}

int zhuanhuan(char *x)

{

       int ans;

       int i;

       for(i=0;i<10;i++)

       {

              if(!strcmp(x,A[i]))

              {

                     ans=i;break;

              }

              if(!strcmp(x,B[i]))

              {

                     ans=i+10;break;

              }

              if(!strcmp(x,C[i]))

              {

                     ans=(i+2)*10;break;

              }

              if(!strcmp(x,D[0]))

              {

                     ans=100;break;

              }

              if(!strcmp(x,D[1]))

              {

                     ans=1000;break;

              }

              if(!strcmp(x,D[2]))

              {

                     ans=1000000;break;

              }

       }

       return ans;

}

void solve(char *x)

{

       int msum(0),hsum(0),tsum(0),sum(0);

       int lenx=strlen(x)-1;

       int i(1),j,beg(1);

       int leny;

       for(j=0;j<=lenx;j=j+leny+1)

       {

              char *y=tiqu(x,j);

              leny=strlen(y);

              strcpy(E[i++],y);

              delete []y;

       }

       int jiE=i-1;

       if(!strcmp(E[1],"negative"))

       {

              if(strcmp(E[2],"zero"))

                     cout<<'-';

              beg++;

       }

       for(beg;beg<=jiE;beg++)

       {

              int z=zhuanhuan(E[beg]);

              if(z==1000000)

              {

                     msum=(tsum+hsum+sum)*1000000;

                     tsum=0;hsum=0;sum=0;

              }

              else if(z==1000)

              {

                     tsum=(hsum+sum)*1000;

                     hsum=0;sum=0;

              }

              else if(z==100)

              {

                     hsum=sum*100;

                     sum=0;

              }

              else

                     sum+=z;

       }

       cout<<msum+tsum+hsum+sum<<endl;

}