| Time Limit: 3000MS | Memory Limit: 65536K | |
| Total Submissions: 4189 | Accepted: 1501 |
Description
Stan has n sticks of various length. He throws them one at a time on the floor in a random way. After finishing throwing, Stan tries to find the top sticks, that is these sticks such that there is no stick on top of them. Stan has noticed that the last thrown stick is always on top but he wants to know all the sticks that are on top. Stan sticks are very, very thin such that their thickness can be neglected.
Input
Input consists of a number of cases. The data for each case start with 1 <= n <= 100000, the number of sticks for this case. The following n lines contain four numbers each, these numbers are the planar coordinates of the endpoints of one stick. The sticks are listed in the order in which Stan has thrown them. You may assume that there are no more than 1000 top sticks. The input is ended by the case with n=0. This case should not be processed.
Output
For each input case, print one line of output listing the top sticks in the format given in the sample. The top sticks should be listed in order in which they were thrown.
The picture to the right below illustrates the first case from input.
The picture to the right below illustrates the first case from input.
Sample Input
5 1 1 4 2 2 3 3 1 1 -2.0 8 4 1 4 8 2 3 3 6 -2.0 3 0 0 1 1 1 0 2 1 2 0 3 1 0
Sample Output
Top sticks: 2, 4, 5. Top sticks: 1, 2, 3.
Hint
Huge input,scanf is recommended.
/***********************************
鏆村姏灝辮錛屼粠絎竴涓紑濮嬪垽鏂?br />濡傛灉涓ゆ潯綰挎鐩鎬氦灝辨妸鍓嶉潰涓鏉＄瓫閫夋帀鍒ゆ柇綰挎鐩鎬氦鐩存帴璐寸殑鍚夊ぇ妯℃澘銆傘傘?br />
***********************************/
#include <iostream>#include <cstdio>#include <cstring>using namespace std;const int maxn = 100000 + 5;const double eps=1e-10;struct point { double x, y; };
point p[maxn], b[maxn];bool ans[maxn];double min(double a, double b) { return a < b ? a : b; }double max(double a, double b) { return a > b ? a : b; }bool inter(point a, point b, point c, point d){ if( min(a.x, b.x) > max(c.x, d.x) || min(a.y, b.y) > max(c.y, d.y) || min(c.x, d.x) > max(a.x, b.x) || min(c.y, d.y) > max(a.y, b.y) ) return 0; double h, i, j, k; h = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); i = (b.x - a.x) * (d.y - a.y) - (b.y - a.y) * (d.x - a.x); j = (d.x - c.x) * (a.y - c.y) - (d.y - c.y) * (a.x - c.x); k = (d.x - c.x) * (b.y - c.y) - (d.y - c.y) * (b.x - c.x); return h * i <= eps && j * k <= eps;}int main(){ int n; int res[maxn]; while( cin >> n, n )
{
memset( ans, 0, sizeof( ans ) ); for( int i = 0; i < n; i++ ) { cin >> p[i].x >> p[i].y >> b[i].x >> b[i].y;
} for( int i = 0; i < n; i++ ) { for( int j = i + 1; j < n; j++ ) { if( inter(p[i], b[i], p[j], b[j] ) ) { ans[i] = 1; break; //涓嶅姞break浼氳秴鏃躲傘傘?/span> } } } int ct = 0; cout << "Top sticks: "; for( int i = 0; i < n; i++ ) if( !ans[i] ) res[ct++] = i + 1; for( int i = 0; i < ct - 1; i++ ) cout << res[i] << ", "; cout << res[ct-1] << "." << endl; } return 0;}]]>
Intersecting Lines
| Time Limit: 1000MS | Memory Limit: 10000K | |
| Total Submissions: 4260 | Accepted: 2049 |
Description
We all know that a pair of distinct points on a plane defines a line and that a pair of lines on a plane will intersect in one of three ways: 1) no intersection because they are parallel, 2) intersect in a line because they are on top of one another (i.e. they are the same line), 3) intersect in a point. In this problem you will use your algebraic knowledge to create a program that determines how and where two lines intersect.
Your program will repeatedly read in four points that define two lines in the x-y plane and determine how and where the lines intersect. All numbers required by this problem will be reasonable, say between -1000 and 1000.
Your program will repeatedly read in four points that define two lines in the x-y plane and determine how and where the lines intersect. All numbers required by this problem will be reasonable, say between -1000 and 1000.
Input
The first line contains an integer N between 1 and 10 describing how many pairs of lines are represented. The next N lines will each contain eight integers. These integers represent the coordinates of four points on the plane in the order x1y1x2y2x3y3x4y4. Thus each of these input lines represents two lines on the plane: the line through (x1,y1) and (x2,y2) and the line through (x3,y3) and (x4,y4). The point (x1,y1) is always distinct from (x2,y2). Likewise with (x3,y3) and (x4,y4).
Output
There should be N+2 lines of output. The first line of output should read INTERSECTING LINES OUTPUT. There will then be one line of output for each pair of planar lines represented by a line of input, describing how the lines intersect: none, line, or point. If the intersection is a point then your program should output the x and y coordinates of the point, correct to two decimal places. The final line of output should read "END OF OUTPUT".
Sample Input
5 0 0 4 4 0 4 4 0 5 0 7 6 1 0 2 3 5 0 7 6 3 -6 4 -3 2 0 2 27 1 5 18 5 0 3 4 0 1 2 2 5
Sample Output
INTERSECTING LINES OUTPUT POINT 2.00 2.00 NONE LINE POINT 2.00 5.00 POINT 1.07 2.20 END OF OUTPUT
]]>
/*****************瀛楃涓插鐞?br />紼沖畾鎺掑簭******************/#include <iostream>#include <algorithm>#include <string>using namespace std;struct DNA{ int pos; int cnt; string str;};bool cmp(const DNA &a, const DNA &b){ if (a.cnt != b.cnt) { return a.cnt < b.cnt; } else { return a.pos < b.pos; }}int main(){ int n, m, count; DNA ans[110]; string str; cin >> n >> m; for (int i = 0; i < m; i++) { cin >> str; count = 0; for (int j = 0; j < n - 1; j++) for (int k = j + 1; k < n; k++) if (str[j] > str[k]) count++; ans[i].str = str; ans[i].cnt = count; ans[i].pos = i; } sort(ans, ans + m, cmp); for (int i = 0; i < m; i++) cout << ans[i].str << endl; return 0;}]]>
/***************************************姣旇緝緇忓吀鐨勪腑鍥藉墿浣欏畾鐞唦~浣?3×28琚?3闄や綑1錛岀敤33×28×6=5544浣?3×33琚?8闄や綑1錛岀敤23×33×19=14421浣?3×28琚?3闄や綑1錛岀敤23×28×2=1288錛?544×p+14421×e+1288×i錛?錛?3×28×33錛?n+dn=錛?544×p+14421×e+1288×i-d錛?錛?3×28×33錛?br />****************************************/#include <iostream>#include <cstdio>using std :: cin;using std :: cout;using std :: endl;int get__( int a, int b, int c ){ int ans; int cnt = 1; while( ( a * b * cnt ) % c != 1 ) { cnt++; } return a * b * cnt;}int main(){ int _p = get__( 28, 33, 23 ); int _e = get__( 23, 33, 28 ); int _i = get__( 23, 28, 33 ); int p, e, i, d; int cas = 1; while( cin >> p >> e >> i >> d ) { if( p == e && e == i && i == d && d == -1 ) break; int ans = ( _p * p + _e * e + _i * i - d ) % ( 23 * 28 * 33 ); if( ans <= 0 ) printf("Case %d: the next triple peak occurs in %d days.\n", cas++, 21252 - ans - 2 * d); else printf("Case %d: the next triple peak occurs in %d days.\n", cas++, ans); } return 0;}]]>
/******************************************璁鵑渶瑕乶騫?br />璁懼崐鍦嗛潰縐負 S錛屽崐寰勪負 rS = 50 * n;S = (PI * r * r) / 2;瑙ｅ緱 n = (PI * r * r ) / 100;鎵緇欑偣鍒板師鐐硅窛紱?nbsp;len = sqrt( x * x + y * y );浠en = r鍗沖彲瑙ｅ嚭 n*******************************************/#include <iostream>#include <cstdio>#include <cmath>const double PI = 3.1415927;using namespace std;int main(){ double x, y; int cnt; cin >> cnt; int pro = 1; while( cnt-- ) { cin >> x >> y; double len = sqrt( x * x + y * y ); int n = (PI * len * len ) / (100 * 1.0); printf("Property %d: This property will begin eroding in year %d.\n", pro++, n + 1); } cout << "END OF OUTPUT.\n"; return 0;}]]>
#include <iostream>#include <cstdio>using std :: cin;using std :: cout;using std :: endl;int main(){ double ans; double tmp; ans = 0; for( int i = 0; i < 12; i++ ) { cin >> tmp; ans += tmp; } cout << "$" << ans / 12.0<< endl; return 0;}]]>
#include <iostream> #include <cstdio> #include <string> using namespace std; const int maxn = 301; string str1, str2; int main() { while( cin >> str1 >> str2 ) { int dp[maxn][maxn] = {0}; int len1 = str1.length(); int len2 = str2.length(); for( int i = 1; i <= len1; i++ ) for( int j = 1; j <= len2; j++ ) { if( str1[i - 1] == str2[j - 1] ) dp[i][j] = dp[i - 1][j - 1] + 1; else dp[i][j] = max( dp[i][j - 1], dp[i - 1][j] ); } printf("%d\n", dp[len1][len2]); } return 0; } ]]>
#include <string.h>
const int maxn = 50;
int b[8]={-2, -2, -1, -1, 1, 1, 2, 2},a[8]={-1, 1, -2, 2, -2, 2, -1, 1};
bool check[maxn][maxn], flag;
int ansx[maxn], ansy[maxn];
int row, col;
void dfs(int x, int y, int sum)
{
if(sum == col * row)
{
for(int i=1; i<=sum; i++)
printf("%c%d", ansy[i]+'A'-1, ansx[i]);
printf("\n");
flag=1;
return;
}
for(int i=0; i<8 && !flag; i++)
{
if(!flag && !check[x+a[i]][y+b[i]] && x+a[i]>0 && x+a[i]<=row && y+b[i]>0 && y+b[i]<=col)
{
ansx[sum+1] = x+a[i];
ansy[sum+1] = y+b[i];
check[x+a[i]][y+b[i]] = 1;
dfs(x+a[i], y+b[i], sum+1);
check[x+a[i]][y+b[i]] = 0;
}
}
}
int main()
{
int n;
int cas;
while(~scanf("%d",&n))
{
cas=1;
while(n--)
{
flag = 0;
memset(check,0,sizeof(check));
printf("Scenario #%d:\n",cas++);
scanf("%d%d", &row, &col);
check[1][1]=1;
ansx[1] = ansy[1] = 1;
dfs(1, 1, 1);
if(!flag) printf("impossible\n");
printf("\n");
}
}
return 0;
}
]]>
#include <cstdio>
using namespace std;
struct CNode
{
int L, R;
CNode * pLeft, * pRight;
long long nSum, Inc;
};
CNode Tree[1000000];
int nCount = 0;
void BuildTree( CNode * pRoot, int L, int R )
{
pRoot->L = L;
pRoot->R = R;
pRoot->nSum = 0;
pRoot->Inc = 0;
if( L == R ) return;
nCount++;
pRoot->pLeft = Tree + nCount;
nCount++;
pRoot->pRight = Tree + nCount;
BuildTree( pRoot->pLeft, L, ( L + R ) / 2 );
BuildTree( pRoot->pRight, ( L + R ) / 2 + 1, R );
}
void Insert( CNode * pRoot, int i, int v )
{
if( pRoot->L == i && pRoot->R == i )
{
pRoot->nSum = v;
return;
}
pRoot->nSum += v;
if( i <= ( pRoot->L + pRoot->R ) / 2 )
Insert( pRoot->pLeft, i, v );
else
Insert( pRoot->pRight, i, v);
}
void Add( CNode * pRoot, int a, int b, long long c )
{
if( a == pRoot->L && b == pRoot->R )
{
pRoot->Inc += c;
return;
}
pRoot->nSum += ( b - a + 1 ) * c;
if( b <= ( pRoot->L + pRoot->R ) / 2)
Add( pRoot->pLeft, a, b, c );
else if ( a >= (pRoot->L + pRoot->R ) / 2 + 1 )
Add ( pRoot->pRight, a, b, c );
else
{
Add( pRoot->pLeft, a, ( pRoot->L + pRoot->R ) / 2, c );
Add( pRoot->pRight, (pRoot->L + pRoot->R ) / 2 + 1, b, c );
}
}
long long QuerynSum( CNode * pRoot, int a, int b )
{
if ( a == pRoot->L && b == pRoot->R )
return (pRoot->nSum + (pRoot->R - pRoot->L + 1 ) * pRoot->Inc);
pRoot->nSum += (pRoot->R - pRoot->L + 1 ) * pRoot->Inc;
Add( pRoot->pLeft, pRoot->L, (pRoot->L + pRoot->R ) / 2, pRoot->Inc );
Add( pRoot->pRight, (pRoot->L + pRoot->R ) / 2 + 1, pRoot->R, pRoot->Inc );
pRoot->Inc = 0;
if( b <= (pRoot->L + pRoot->R ) /2 )
return QuerynSum( pRoot->pLeft, a, b );
else if ( a >= (pRoot->L + pRoot->R ) / 2 + 1 )
return QuerynSum ( pRoot->pRight, a, b);
else
return QuerynSum( pRoot->pLeft, a, (pRoot->L +pRoot->R ) / 2 ) + QuerynSum( pRoot->pRight, (pRoot->L + pRoot->R ) / 2 + 1, b ) ;
}
int main()
{
int n,q;
scanf("%d%d", &n, &q );
nCount = 0;
BuildTree( Tree, 1, n);
int temp;
for( int i = 1; i <= n; i++ )
{
scanf("%d", &temp);
Insert( Tree, i, temp );
}
char c_temp[10];
int a, b, c;
for( int i = 0; i < q; i++ )
{
scanf("%s", c_temp);
if( c_temp[0] == 'C' )
{
scanf("%d%d%d", &a, &b, &c );
Add( Tree, a, b, c);
}
else
{
scanf("%d%d", &a, &b );
printf("%I64d\n",QuerynSum( Tree, a, b ));
}
}
return 0;
}
]]>
#include <cstdio>
#include <algorithm>
const int MY_MAX = -99999999;
const int MY_MIN = 99999999;
using namespace std;
struct CNode
{
int R, L;
int nMax, nMin;
CNode * pLeft, * pRight;
}Tree[1000000];
//CNode Tree[1000000];
int nMax, nMin;
int nCount = 0;
void BuildTree( CNode * pRoot, int L, int R )
{
pRoot->L = L;
pRoot->R = R;
pRoot->nMax = MY_MAX;
pRoot->nMin = MY_MIN;
if( R != L )
{
nCount++;
pRoot->pLeft = Tree + nCount;
nCount++;
pRoot->pRight = Tree + nCount;
BuildTree( pRoot->pLeft, L, ( L + R ) / 2 );
BuildTree( pRoot->pRight, ( L + R ) / 2 + 1, R );
}
}
void Insert( CNode * pRoot, int i, int v )
{
if( pRoot->L == i &&pRoot-> R == i )
{
pRoot-> nMin = pRoot-> nMax = v;
return ;
}
pRoot->nMin = min( pRoot->nMin,v );
pRoot->nMax = max( pRoot->nMax, v );
if( i <= ( pRoot->L + pRoot->R ) / 2 )
Insert( pRoot->pLeft, i, v );
else
Insert( pRoot->pRight, i, v );
}
void Query( CNode * pRoot, int s, int e )
{
if( pRoot->nMax <= nMax && pRoot->nMin >= nMin )
return ;
if( s == pRoot->L && e == pRoot->R )
{
nMax = max(pRoot->nMax, nMax);
nMin = min(pRoot->nMin,nMin);
return;
}
if( e <= ( pRoot->L + pRoot->R ) / 2 )
Query( pRoot->pLeft, s, e );
else if ( s >= ( pRoot->L + pRoot->R ) / 2 + 1 )
Query( pRoot->pRight, s, e );
else
{
Query( pRoot->pLeft, s, ( pRoot->L + pRoot->R ) / 2 );
Query( pRoot->pRight, ( pRoot->L + pRoot->R) / 2 + 1, e ) ;
}
}
int main()
{
int n, q, s, e;
int h;
scanf("%d%d", &n, &q);
nCount = 0;
BuildTree( Tree, 1, n);
for( int i = 1; i <= n; i++ )
{
scanf("%d", &h);
Insert( Tree, i, h );
}
for( int i = 0; i < q; i++)
{
scanf("%d%d", &s,&e );
nMax = MY_MAX;
nMin = MY_MIN;
Query( Tree, s, e );
printf("%d\n", nMax - nMin) ;
}
return 0;
}
]]>
#include <cstdio>
const int maxn = 30000 + 5;
using namespace std;
int father[maxn],rank[maxn];
void init( int n )
{
for ( int i = 0; i < n; i++)
{
father[i] = i;
rank[i] = 1;
}
}
int findSet( int n )
{
if(father[n] != n)
father[n] = findSet(father[n]);
return father[n];
}
void Union( int a, int b )
{
int x = findSet( a );
int y = findSet( b );
if( x == y ) return ;
if( rank[x] >= rank[y] )
{
father[y] = x;
rank[x] += rank[y];
}
else
{
father[x] = y;
rank[y] += rank[x];
}
}
int main()
{
int m, n, count, temp, first;
while( ~scanf("%d%d", &n, &m ) && n )
{
init(n);
while( m-- )
{
scanf("%d%d", &count, &first );
for( int i = 1; i < count ;i ++)
{
scanf("%d", &temp);
Union( first, temp );
}
}
printf("%d\n",rank[findSet(0)]);
}
return 0;
}
]]>
#include <algorithm>
#include <math.h>
using namespace std;
int n;
struct CPost
{
int L,R;
};
CPost posters[10100];
int x[20200];
int hash[10000010];
struct CNode
{
int L,R;
bool bCovered; //鏈尯闂存槸鍚﹀凡緇忚瀹屽叏瑕嗙洊
CNode * pLeft, * pRight;
};
CNode Tree[100000];
int nNodeCount = 0;
int Mid( CNode * pRoot)
{
return (pRoot->L + pRoot->R)/2;
}
void BuildTree( CNode * pRoot, int L, int R)
{
pRoot->L = L;
pRoot->R = R;
pRoot->bCovered = false;
if( L == R )
return;
nNodeCount ++;
pRoot->pLeft = Tree + nNodeCount;
nNodeCount ++;
pRoot->pRight = Tree + nNodeCount;
BuildTree( pRoot->pLeft,L,(L+R)/2);
BuildTree( pRoot->pRight,(L+R)/2 + 1,R);
}
bool Post( CNode *pRoot, int L, int R)
{
if( pRoot->bCovered )
return false;
if( pRoot->L == L && pRoot->R == R) {
pRoot->bCovered = true;
return true;
}
bool bResult ;
if( R <= Mid(pRoot) )
bResult = Post( pRoot->pLeft,L,R);
else if( L >= Mid(pRoot) + 1)
bResult = Post( pRoot->pRight,L,R);
else {
bool b1 = Post(pRoot->pLeft ,L,Mid(pRoot));
bool b2 = Post( pRoot->pRight,Mid(pRoot) + 1,R);
bResult = b1 || b2;
}
//瑕佹洿鏂版牴鑺傜偣鐨勮鐩栨儏鍐?/span>
if( pRoot->pLeft->bCovered && pRoot->pRight->bCovered )
pRoot->bCovered = true;
return bResult;
}
int main()
{
int t;
int i,j,k;
scanf("%d",&t);
int nCaseNo = 0;
while(t--) {
nCaseNo ++;
scanf("%d",&n);
int nCount = 0;
for( i = 0;i < n;i ++ ) {
scanf("%d%d", & posters[i].L,& posters[i].R );
x[nCount++] = posters[i].L;
x[nCount++] = posters[i].R;
}
sort(x,x+nCount);
nCount = unique(x,x+nCount) - x; //鍘繪帀閲嶅鍏冪礌
for( i = 0;i < nCount;i ++ )
hash[x[i]] = i;
nNodeCount = 0;
BuildTree( Tree,0,nCount - 1);
int nSum = 0;
for( i = n - 1;i >= 0;i -- ) { // 浠庡悗寰鍓嶇湅鏉挎槸鍚︾湅寰楄
if( Post(Tree,hash[posters[i].L],hash[posters[i].R]))
nSum ++;
}
printf("%d\n",nSum);
}
return 0;
}
]]>
| Time Limit: 500MS | Memory Limit: 10000K | |
| Total Submissions: 68964 | Accepted: 16146 |
Description
Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many computer systems.
This problem requires that you write a program to compute the exact value of Rn where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.
This problem requires that you write a program to compute the exact value of Rn where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.
Input
The input will consist of a set of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.
Output
The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.
Sample Input
95.123 12 0.4321 20 5.1234 15 6.7592 9 98.999 10 1.0100 12
Sample Output
548815620517731830194541.899025343415715973535967221869852721 .00000005148554641076956121994511276767154838481760200726351203835429763013462401 43992025569.928573701266488041146654993318703707511666295476720493953024 29448126.764121021618164430206909037173276672 90429072743629540498.107596019456651774561044010001 1.126825030131969720661201
铏界劧鏁堢巼浣庣偣鍎匡紝浣嗕唬鐮侀潪甯哥畝鍗曪紝瀹規槗瀹炵幇錛岀湡姝ｆ瘮璧涜繕鏄緢濂界敤鐨勩傘傘?br />import java.io.*;
import java.util.*;
import java.math.*;
public class Main{
public static void main( String args[] )
{
BigDecimal num;
int n;
String r;
Scanner cin = new Scanner(System.in);
while(cin.hasNextBigDecimal())
{
num = cin.nextBigDecimal();
n = cin.nextInt();
num = num.pow(n);
r = num.stripTrailingZeros().toPlainString();//BigDecimal.toPlainString 閬垮厤杈撳嚭鏃朵駭鐢熺瀛﹁鏁版硶褰㈠紡
if(r.startsWith("0."))
r = r.substring(1);
System.out.println(r);
}
}
}
]]>