Instruction stringlengths 0 6.61k | Rejected stringlengths 70 490k | Chosen stringlengths 54 490k | Language stringclasses 1
value | Aspect stringclasses 1
value | Source stringclasses 1
value |
|---|---|---|---|---|---|
QQ
==
Write a program which prints multiplication tables in the following format:
```
1x1=1
1x2=2
.
.
9x8=72
9x9=81
```
Input
-----
No input.
Output
------
```
1x1=1
1x2=2
.
.
9x8=72
9x9=81
```
Template for C
--------------
```
#include<stdio.h>
int main(){
return 0;
}
```
Template for C++
----------------
```
#include<iostream>
using namespace std;
int main(){
return 0;
}
```
Template for Java
-----------------
```
class Main{
public static void main(String[] a){
}
}
```
| #include <iostream>
using namespace std;
int main()
{
for(int i=1;i<=9;i++)
{
for(int j=1;j<=9;j++)
{
cout<<i<<"x"<<j<<"="<<(i*j)<<endl;
}
}
return 0;
} | #include<stdio.h>
int main()
{
int i,j,mt=0;
for(i=1;i<10;i++)
{
for(j=1;j<10;j++)
{
mt = i * j;
printf("%dx%d=%d\n",i,j,mt);
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Digit Number
============
Write a program which computes the digit number of sum of two integers a and b.
Input
-----
There are several test cases. Each test case consists of two non-negative integers a and *b* which are separeted by a space in a line. The input terminates with EOF.
Constraints
-----------
* 0 ≤ a, b ≤ 1,000,000
* The number of datasets ≤ 200
Output
------
Print the number of digits of a + b for each data set.
Sample Input
------------
```
5 7
1 99
1000 999
```
Output for the Sample Input
---------------------------
```
2
3
4
```
| #import <iostream>
#import <sstream>
using namespace std;
void problemOne(){
int a;
int b;
while (cin >> a >> b){
int sum = a + b;
int intLength = 0;
while (sum != 0) {
sum /= 10;
intLength += 1;
}
cout << intLength << endl;
}
}
int main(){
problemOne();
} | #include<cstdio>
int main(){
int n,n1,n2,count,a;
while(scanf("%d%d",&n1,&n2)!=EOF){
count=0;
a=n1+n2;
while(a!=0){
a=a/10;
count++;
}
printf("%d\n",count);
}
return 0;
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
GCD and LCM
===========
Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given a and b.
Input
-----
Input consists of several data sets. Each data set contains a and b separated by a single space in a line. The input terminates with EOF.
Constraints
-----------
* 0 < a, b ≤ 2,000,000,000
* LCM(a, b) ≤ 2,000,000,000
* The number of data sets ≤ 50
Output
------
For each data set, print GCD and LCM separated by a single space in a line.
Sample Input
------------
```
8 6
50000000 30000000
```
Output for the Sample Input
---------------------------
```
2 24
10000000 150000000
```
| #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
long long int num1 , num2, gcd , res, lcm;
while(scanf("%lld%lld",&num1,&num2)!=EOF){
res = num1 * num2 ;
while(num1 != num2){
if(num1 > num2)
num1 = num1 - num2 ;
else
num2 = num2 - num1 ;
}
gcd = num1 ;
lcm = res / gcd ;
printf("%lld %lld\n", gcd, lcm);
}
return 0;
} | #include<stdio.h>
#define LL long long
LL GCD(LL a,LL b)
{
return b==0?a:GCD(b,a%b);
}
int main()
{
LL a,b;
while(scanf("%lld%lld",&a,&b)!=EOF)
{
LL c=GCD(a,b);
printf("%lld %lld\n",c,a/c*b);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Prime Number
============
Write a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Input
-----
Input consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.
The number of datasets is less than or equal to 30.
Output
------
For each dataset, prints the number of prime numbers.
Sample Input
------------
```
10
3
11
```
Output for the Sample Input
---------------------------
```
4
2
5
```
| #include<stdio.h>
#include<math.h>
bool flag[1000000];
int main(void)
{
long long i,j,p,n,count;
p = (long long)sqrt(1000000.0);
for(i = 3; i <= p; i = i + 2)
{
if(flag[i] == false)
{
for(j = i * i; j <= 1000000; j = j + 2 * i)
{
flag[j] = true;
}
}
}
while((scanf("%lld",&n)) != EOF)
{
if(n == 1 || n == 0)
count = 0;
else
{
count = 1;
for(i = 3; i <= n; i = i + 2)
{
if(flag[i] == false)
count++;
}
}
printf("%lld\n",count);
}
return 0;
} | #include<cstdio>
using namespace std;
#define MAX 1000000
int prime[MAX];
bool is_prime[MAX];
int sieve(int n){ //埃氏?
int p=0;
for(int i=0;i<=n;i++)
is_prime[i]=true;
is_prime[0]=is_prime[1]=false;
for(int i=2;i<=n;i++){
if(is_prime[i]){
prime[p++]=i; //??素数的个数和素数的?
for(int j=2*i;j<=n;j+=i)
is_prime[j]=false;
}
}
return p;
}
int main()
{
int num;
while(scanf("%d",&num)!=EOF){
printf("%d\n",sieve(num));
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Prime Number
============
Write a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Input
-----
Input consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.
The number of datasets is less than or equal to 30.
Output
------
For each dataset, prints the number of prime numbers.
Sample Input
------------
```
10
3
11
```
Output for the Sample Input
---------------------------
```
4
2
5
```
| #include <cstdio>
using namespace std;
int main() {
long NUM = 1000000;
long n;
long counter = 0;
bool primeNum[NUM + 10];
long i, ii, j, len = NUM + 10;
primeNum[0] = primeNum[1] = false;
for (i = 2; i < len; i++) primeNum[i] = true;
ii = 4;
for(i = 2; ii < NUM;) {
if (primeNum[i]) {
for (j = ii; j < NUM; j += i) {
primeNum[j] = false;
}
}
i++;
ii = i * i;
}
while (scanf("%ld", &n) != EOF) {
counter = 0;
for (i = 0; i <= n; i++) {
if (primeNum[i]) counter++;
}
printf("%ld\n", counter);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
static const long MAX = 1000000L;
int main() {
vector<long> prime;
vector<long> dp;
bool isPrime;
long n, m;
long i, len = sqrt(MAX) + 1;
long j, lenJ;
long k;
prime.push_back(2);
dp.push_back(0);
dp.push_back(0);
dp.push_back(1);
for (i = 3; i <= len; i += 2) {
isPrime = true;
lenJ = prime.size();
k = sqrt(i) + 1;
for (j = 0; j < lenJ; j++) {
if (k <= prime[j]) break;
if (i % prime[j] == 0) {
isPrime = false;
break;
}
}
if (isPrime) prime.push_back(i);
}
lenJ = prime.size();
while (cin >> n) {
if (n < dp.size()) {
cout << dp[n] << endl;
continue;
}
m = dp.size();
for (i = m; i <= n; i += 2) {
isPrime = true;
k = sqrt(i) + 1;
for (j = 0; j < lenJ; j++) {
if (k <= prime[j]) break;
if (i % prime[j] == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
dp.push_back(dp.back() + 1);
dp.push_back(dp.back());
} else {
dp.push_back(dp.back());
dp.push_back(dp.back());
}
}
cout << dp[n] << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Prime Number
============
Write a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Input
-----
Input consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.
The number of datasets is less than or equal to 30.
Output
------
For each dataset, prints the number of prime numbers.
Sample Input
------------
```
10
3
11
```
Output for the Sample Input
---------------------------
```
4
2
5
```
| #include <iostream>
using namespace std;
int main() {
int judge[1000000];
for(int k=0;k<1000000;k++)judge[k]=1;
int n,sum;
while(cin>>n){
if(n==0||n==1){
sum = 0;
}else{
sum = 1;
for(int i=3;i<n+1;i+=2){
if (judge[i]==1){
sum++;
for(int j=2;j<=n/i;j++)
judge[i*j] = 0;
}
}
}
cout << sum <<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
vector<int> ns;
int temp, max_n = 0;
while(cin >> temp){
ns.push_back(temp);
max_n = max(temp, max_n);
}
max_n++;
vector<bool> is_prime(max_n, true);
vector<int> primes;
for(ll i=2;i<max_n;i++){
if(is_prime[i]){
primes.push_back(i);
for(ll j=i*i;j<max_n;j+=i){
is_prime[j] = false;
}
}
}
for(int n: ns){
int ans = upper_bound(primes.begin(), primes.end(), n) - primes.begin();
cout << ans << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Prime Number
============
Write a program which reads an integer n and prints the number of prime numbers which are less than or equal to n. A prime number is a natural number which has exactly two distinct natural number divisors: 1 and itself. For example, the first four prime numbers are: 2, 3, 5 and 7.
Input
-----
Input consists of several datasets. Each dataset has an integer n (1 ≤ n ≤ 999,999) in a line.
The number of datasets is less than or equal to 30.
Output
------
For each dataset, prints the number of prime numbers.
Sample Input
------------
```
10
3
11
```
Output for the Sample Input
---------------------------
```
4
2
5
```
| #include<iostream>
using namespace std;
int main(){
int n, cnt;
while(cin >> n){
bool prime[1000000] = {false};
prime[1] = true; //1???????????\
// ??¨??????????????????????????????
for(int j = 2; j*j <= n; j++){
if(prime[j] == false){
for(int k = j; k*j <= n; k++){
prime[j*k] =true;
}
}
}
cnt = 0;
for(int i = 1; i <= n; i++){
if(prime[i] == false) cnt++;
}
cout << cnt << endl;
}
} | #include<iostream>
using namespace std;
int main(){
int n, cnt;
while(cin >> n){
bool prime[n+1] = {false};
prime[1] = true;
// ??¨??????????????????????????????
for(int j = 2; j*j <= n; j++){
if(prime[j] == false){
for(int k = j; k*j <= n; k++){
prime[j*k] = true;
}
}
}
cnt = 0;
for(int i = 1; i <= n; i++){
if(prime[i] == false) cnt++;
}
cout << cnt << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Maximum Sum Sequence
====================
Given a sequence of numbers a1, a2, a3, ..., an, find the maximum sum of a contiguous subsequence of those numbers. Note that, a subsequence of one element is also a *contiquous* subsequence.
Input
-----
The input consists of multiple datasets. Each data set consists of:
```
n
a1
a2
.
.
an
```
You can assume that 1 ≤ n ≤ 5000 and -100000 ≤ ai ≤ 100000.
The input end with a line consisting of a single 0.
Output
------
For each dataset, print the maximum sum in a line.
Sample Input
------------
```
7
-5
-1
6
4
9
-6
-7
13
1
2
3
2
-2
-1
1
2
3
2
1
-2
1
3
1000
-200
201
0
```
Output for the Sample Input
---------------------------
```
19
14
1001
```
| #include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n;
int a[5000];
int tmp;
int ans;
while(1){
cin >> n;
if(!n)break;
for(int i=0;i<n;i++){
cin >> a[i];
}
ans = a[0];
for(int i=0;i<n;i++){
for(int j=i;j<n;j++){
if(i==j)tmp = a[i];
else tmp += a[j];
ans = max(tmp,ans);
}
}
cout << ans << endl;
}
} | #include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int n,tmp,ans;
int a[5000];
while(scanf("%d",&n) && n){
for(int i=0;i<n;i++)scanf("%d",&a[i]);
ans = a[0];
for(int i=0;i<n;i++)
for(int j=i;j<n;j++){
if(i==j)tmp = a[i];
else tmp += a[j];
ans = max(tmp,ans);
}
printf("%d\n",ans);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Maximum Sum Sequence
====================
Given a sequence of numbers a1, a2, a3, ..., an, find the maximum sum of a contiguous subsequence of those numbers. Note that, a subsequence of one element is also a *contiquous* subsequence.
Input
-----
The input consists of multiple datasets. Each data set consists of:
```
n
a1
a2
.
.
an
```
You can assume that 1 ≤ n ≤ 5000 and -100000 ≤ ai ≤ 100000.
The input end with a line consisting of a single 0.
Output
------
For each dataset, print the maximum sum in a line.
Sample Input
------------
```
7
-5
-1
6
4
9
-6
-7
13
1
2
3
2
-2
-1
1
2
3
2
1
-2
1
3
1000
-200
201
0
```
Output for the Sample Input
---------------------------
```
19
14
1001
```
| #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
vector<int> v,s(10001);
int a,b,n,o=0;
while(cin>>b){
fill(s.begin(),s.end(),0);
o =0;
if(b==0) break;
else{
for(int i=0;i<b;i++){
cin>>a;
v.push_back(a);
}
for(int i = 0; i < b; i++){
int sum = 0;
for(int j = i; j < b; j++){
sum += v[j];
s.push_back(sum);
}
}
int d = *max_element(s.begin(),s.end());
cout<<d<<endl;
}
s.clear(),v.clear();
}
} | #include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <complex>
#include <ctime>
#include <cstdlib>
using namespace std;
inline int to_int(string s) {int v; istringstream sin(s); sin >> v; return v;}
template<class T> inline string to_str(T x) {ostringstream sout; sout << x; return sout.str();}
typedef long long ll;
int main()
{
int n, T[5001], dp[5001];
while(cin >> n, n)
{
for(int i = 0; i < n; i++)
{
cin >> T[i];
}
memset(dp, -1, sizeof(dp));
dp[0] = T[0];
for(int i = 1; i < n; i++)
{
dp[i] = max(dp[i-1] + T[i], T[i]);
}
int res = -10000000;
for(int i = 0; i < n; i++)
{
res = max(res, dp[i]);
}
cout << res << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
玉
=
図のように二股に分かれている容器があります。1 から 10 までの番号が付けられた10 個の玉を容器の開口部 A から落とし、左の筒 B か右の筒 C に玉を入れます。板 D は支点 E を中心に左右に回転できるので、板 D を動かすことで筒 B と筒 C のどちらに入れるか決めることができます。
開口部 A から落とす玉の並びを与えます。それらを順番に筒 B 又は筒 Cに入れていきます。このとき、筒 B と筒 C のおのおのが両方とも番号の小さい玉の上に大きい玉を並べられる場合は YES、並べられない場合は NO と出力するプログラムを作成してください。ただし、容器の中で玉の順序を入れ替えることはできないものとします。また、続けて同じ筒に入れることができるものとし、筒 B, C ともに 10 個の玉がすべて入るだけの余裕があるものとします。
Input
-----
複数のデータセットが与えられます。１行目にデータセット数 N が与えられます。つづいて、N 行のデータセットが与えられます。各データセットに 10 個の番号が左から順番に空白区切りで与えられます。
Output
------
各データセットに対して、YES または NO を１行に出力して下さい。
Sample Input
------------
```
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
```
Output for the Sample Input
---------------------------
```
YES
NO
```
| #include<bits/stdc++.h>
using namespace std;
int a[20];
bool check(int x)
{
int pre = 0;
for (int i = 0; i < 10; i++) if (x & (1 << i))
{
if (a[i] < pre) return false;
pre = a[i];
}
return true;
}
bool dfs(int i, int x, int pre)
{
if (i == 10)
{
return check(x);
}
bool temp = false;
if (a[i] > pre) temp = dfs(i + 1, x, a[i]);
return temp || dfs(i + 1, x | (1 << i), pre);
}
int main()
{
int T;
cin >> T;
while (T--)
{
for (int i = 0; i < 10; i++) scanf("%d", &a[i]);
printf("%s\n", dfs(1, 0, a[0]) ? "YES" : "NO");
}
return 0;
} | #include<cstdio>
int a,l1,l2,n;
bool f;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
f=0;l1=0;l2=-1;
for(int j=1;j<=10;j++)
{
scanf("%d",&a);
if(!f&&a<l2&&a<l1){printf("NO\n");f=1;continue;}
if(!f&&l1>l2)
{
if(l1<a)l1=a;
else l2=a;
}
if(!f&&l2>l1)
{
if(l2<a)l2=a;
else l1=a;
}
}
if(!f)printf("YES\n");
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
アフィン暗号
======
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
```
that
this
```
のいずれかが必ず含まれているものとします。
Input
-----
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
Output
------
各データセットに対して、復号した元の文章を１行に出力して下さい。
Sample Input
------------
```
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
```
Output for the Sample Input
---------------------------
```
i submit that there is another point of view
```
| #include <iostream>
#include <map>
#include <sstream>
#include <string.h>
using namespace std;
map<int, char> AlphabetTable;
map<int, int> table;
char decode(char a){
int z = a - 'a';
for(int i = 0; i < 26; i++){
if(table[i] == z) return AlphabetTable[i];
}
}
void makeTable(int a, int b){
for(int i = 0; i < 26; i++){
table[i] = (a*i+b) % 26;
}
}
void makeAlphabetTable(){
char c = 'a';
for(int i = 0; i < 26; i++){
AlphabetTable[i] = c;
c++;
}
}
int main(){
string code, tmp;
int n;
getline (cin, code);
stringstream ssn(code);
ssn >> n;
makeAlphabetTable();
for(int i = 0; i < n; i++){
getline(cin, code );
tmp = code;
for(int b = 0; b < 26; b++){
for(int a = 1; a < 26; a+=2){
if(a%13 != 0){
makeTable(a, b);
code = tmp;
for(int j = 0; j < code.length(); j++){
if('a' <= code[j] && code[j] <= 'z'){
code[j] = decode(code[j]);
}
}
if(code.find("this") != -1 || code.find("that")!= -1){
cout << code << endl;
break;
}
}
}
}
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
void solve()
{
int N;
scanf("%d\n", &N);
while(N--)
{
string s;
getline(cin, s);
string sbuf = s;
sbuf += ' ';
int n = sbuf.size();
int start = 0;
int end = 0;
vector<string> Vec;
string temp;
for(int i = 0; i < n; ++i)
{
if(sbuf[i] == ' ')
{
if(end - start == 4)
{
Vec.push_back(temp);
}
start = end = i + 1;
temp.clear();
continue;
}
temp += sbuf[i];
++end;
}
int a = 0;
int b = 0;
for(int i = 0; i < Vec.size(); ++i)
{
for(int j = 0; j < 4; ++j)
{
Vec[i][j] %= 26;
}
}
for(int i = 0; i < 26; ++i)
{
for(int j = 0; j < 27; ++j)
{
for(int k = 0; k < Vec.size(); ++k)
{
string check = "asdf";
for(int l = 0; l < 4; ++l)
{
check[l] = (i * Vec[k][l] + j) % 26 + 'a';
}
if(check == "this" || check == "that")
{
a = i;
b = j;
goto END;
}
}
}
}
END:
n = s.size();
for(int i = 0; i < n; ++i)
{
if(s[i] == ' ')
{
cout << s[i];
continue;
}
s[i] = (a * (s[i] % 26) + b) % 26 + 'a';
cout << s[i];
}
cout << endl;
}
}
int main()
{
solve();
return(0);
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
アフィン暗号
======
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
```
that
this
```
のいずれかが必ず含まれているものとします。
Input
-----
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
Output
------
各データセットに対して、復号した元の文章を１行に出力して下さい。
Sample Input
------------
```
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
```
Output for the Sample Input
---------------------------
```
i submit that there is another point of view
```
| #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <sstream>
#include <fstream>
#include <set>
#include <map>
using namespace std;
class AffineCipher
{
public:
string decode (string, vector <int> );
vector<int> make_alpha (void);
private:
int gcd (int, int );
bool decide_variable (int, int, string );
bool check_code (string );
};
int AffineCipher::gcd (int a, int b )
{
if (a > b){
swap(a,b);
} // end if
while (b % a != 0 ){
b = b % a;
if (a > b ){
swap(a, b );
} // end if
} // end while
return a;
}
bool AffineCipher::decide_variable (int a, int b, string str )
{
set <char> code;
set <char> source;
int i;
for (i = 0; i < str.length(); ++i ){
if (isalpha(str[i]) ){
source.insert (str[i] );
} // end if
} // end for
set <char>::iterator it = source.begin();
for (; it != source.end(); ++it ){
char c = (a*((*it) - 'a' ) + b ) % 26 + 'a';
if (code.count (c) ){
return false;
}else{
code.insert (c);
} // end if
} // end for
return true;
}
bool AffineCipher::check_code (string str )
{
const string keyword[] = { "this", "that" };
for (int i = 0; i < sizeof(keyword)/sizeof(keyword[0]); ++i){
if (str.find(keyword[i] ) != string::npos ){
return true;
} // end if
} // end for
return false;
}
string AffineCipher::decode (string str, vector <int> alpha )
{
int len = str.length();
int a, b;
multimap <int, int> table;
int i;
for (i = 0; i < alpha.size(); ++i){
a = alpha[i];
for (b = 0; b < 26; ++b){
if (!decide_variable (a, b, str ) ){
continue;
}else{
table.insert (make_pair (a, b ) );
} // end if
} // end for
} // end for
string res = "";
multimap <int, int>::iterator it = table.begin();
for (; it != table.end(); ++it){
a = (*it).first;
b = (*it).second;
res = "";
for (i = 0; i < len; ++i){
char c = 0;
if (isalpha(str[i] ) ){
c = (a*(str[i] - 'a' ) + b ) % 26 + 'a';
}else{
c = str[i];
} // end if
res += c;
} // end for
if (!check_code (res ) ){
continue;
}else{
break;
} // end if
} // end for
return res;
}
vector <int> AffineCipher::make_alpha (void)
{
vector <int> alpha;
int i;
for (i = 1; i < 26; ++i){
if (gcd(i, 26 ) == 1 ){
alpha.push_back(i);
} // end if
} // end for
return alpha;
}
int main()
{
AffineCipher AC;
// cut here before submit
// freopen("testcase.ac", "r", stdin);
string str = "";
int n;
getline (cin, str );
stringstream ssn(str);
ssn >> n;
vector <int> alpha = AC.make_alpha();
int i;
for (i = 0; i < n; ++i){
string res = "";
getline (cin, str );
res = AC.decode (str, alpha );
cout << res << endl;
} // end for
return 0;
} | #include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cstdlib> // require abs exit atof atoi
#include <cstdio> // require scanf printf
#include <functional>
#include <numeric> // require accumulate
#include <cmath> // require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip> // require setw
#include <sstream> // require stringstream
#include <cstring> // require memset
#include <cctype> // require tolower, toupper
#include <fstream> // require freopen
#include <ctime> // require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const string keyword[] = {"that", "this" };
int affine (int a, int b, int x )
{
return ((a*x + b ) % 26 );
}
int main()
{
// cut here before submit
// freopen ("testcase.AC", "r", stdin );
int n;
string sn = "";
getline (cin, sn );
stringstream ssn (sn );
ssn >> n;
// scanf ("%d", &n );
rep (i, n ){
string str = "";
getline (cin, str );
int m = str.length();
string res = "";
for (int a = 1; a <= 26; a++ ){
if (__gcd (a, 26 ) != 1 ) continue;
for (int b = 0; b <= 26; b++ ){
string s = str;
rep (i, m ){
if (isalpha(s[i] ) ){
char c = (char)(affine (a, b, (int)(s[i] - 'a') ) + 'a' );
if (isalpha (c ) ){
s[i] = c;
} // end if
} // end if
} // end rep
// cerr << "s: " << s << endl;
rep (i, 2 ){
if (s.find (keyword[i] ) != string::npos ){
res = s;
break;
} // end if
} // end rep
if (!res.empty() ) break;
} // end for
if (!res.empty() ) break;
} // end for
cout << res << endl;
} // end loop
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
アフィン暗号
======
簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。
$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$
ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。
暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして
```
that
this
```
のいずれかが必ず含まれているものとします。
Input
-----
複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。
Output
------
各データセットに対して、復号した元の文章を１行に出力して下さい。
Sample Input
------------
```
1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw
```
Output for the Sample Input
---------------------------
```
i submit that there is another point of view
```
| #include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstdio>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define it ::iterator
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double ESP=1e-10;
using namespace std;
int main(){
int n;
cin>>n;
rep(i,n){
string s;
string ans;
bool han=false;
if(i==0)getline(cin,s);
getline(cin,s);
rep(a,27){
rep(b,27){
string tmp=s;
rep(j,tmp.size())if(isalpha(tmp[j]))tmp[j]=(a*(tmp[j]-'a')+b)%26+'a';
rep(j,tmp.size()-3){
if(tmp.substr(j,4)=="this"){ans=tmp;han=true;}
if(tmp.substr(j,4)=="that"){ans=tmp;han=true;}
}
if(han==true)break;
}
if(han==true)break;
}
cout<<ans<<endl;
}
} | #include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
int main(){
int n;
cin>>n;
string s;
getline(cin,s);
while(n--){
getline(cin,s);
bool h=false;
rep(i,26){
string tmp;
rep(j,26){
tmp=s;
rep(k,tmp.size())if(isalpha(tmp[k]))tmp[k]=(i*(tmp[k]-'a')+j)%26+'a';
rep(k,tmp.size()-3){
string a=tmp.substr(k,4);
if(a=="this"||a=="that"){h=true;break;}
}
if(h)break;
}
if(h){s=tmp;break;}
}
cout<<s<<endl;;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
式
=
与えられた 4 つの 1 から 9 の整数を使って、答えが 10 になる式をつくります。
4 つの整数 a, b, c, d を入力したとき、下記の条件に従い、答えが 10 になる式を出力するプログラムを作成してください。また、答えが複数ある時は、最初に見つかった答えだけを出力するものとします。答えがない時は、0 と出力してください。
* 演算子として、加算 (+)、減算 (-)、乗算 (\*) だけを使います。除算 (/) は使いません。使用できる演算子は３個です。
* 数を4つとも使わなければいけません。
* 4つの数の順番は自由に入れ換えてかまいません。
* カッコを使ってもかまいません。使用できるカッコは３組（６個）以下です。
Input
-----
複数のデータセットが与えられます。各データセットの形式は以下のとおり：
```
a b c d
```
入力は４つの 0 で終了します。データセットの数は 40 を超えません。
Output
------
各データセットについて、与えられた 4 つの整数と上記の演算記号およびカッコを組み合わせて値が 10 となる式または 0 を１行に出力してください。式の文字列が 1024 文字を超えてはいけません。
Sample Input
------------
```
8 7 9 9
4 4 4 4
5 5 7 5
0 0 0 0
```
Output for the Sample Input
---------------------------
```
((9 * (9 - 7)) - 8)
0
((7 * 5) - (5 * 5))
```
| #include <cstdio>
using namespace std;
int a[4];
int c[8];
int k;
int calc(){
int op = c[k++];
int ret = 0;
if(op >= 0){
ret = op;
}
else if(op >= -3){
int x = calc();
int y = calc();
if(op == -1){
ret = x + y;
}
else if(op == -2){
ret = x - y;
}
else{
ret = x * y;
}
}
else{
throw 0;
}
return ret;
}
void print(){
int op = c[k++];
if(op >= 0){
printf("%d", op);
}
else{
char ch;
if(op == -1){ ch = '+'; }
else if(op == -2){ ch = '-'; }
else{ ch = '*'; }
putchar('(');
print();
printf(" %c ", ch);
print();
putchar(')');
}
}
void solve(int i, int S, int oprem){
if(i == 7){
try{
if(S == 0){
k = 0;
if(calc() == 10 && k == 7){
k = 0;
print();
puts("");
throw "";
}
}
}catch(int){}
return;
}
if(oprem > 0){
for(int op = -1; op >= -3; --op){
c[i] = op;
solve(i + 1, S, oprem - 1);
}
}
for(int j = 0; j < 4; ++j){
if(S >> j & 1){
c[i] = a[j];
solve(i + 1, S ^ 1 << j, oprem);
}
}
}
int main(){
while(1){
for(int i = 0; i < 8; ++i){
c[i] = -9;
}
for(int i = 0; i < 4; ++i){
scanf("%d", &a[i]);
}
if(a[0] == 0){ break; }
try{
solve(0, 15, 3);
puts("0");
}catch(...){}
}
} | #include <cstdio>
using namespace std;
int a[4];
int c[8];
int k;
int calc(){
int op = c[k++];
int ret = 0;
if(op >= 0){
ret = op;
}
else if(op >= -3){
int x = calc();
int y = calc();
if(op == -1){
ret = x + y;
}
else if(op == -2){
ret = x - y;
}
else{
ret = x * y;
}
}
else{
throw 0;
}
return ret;
}
void print(){
int op = c[k++];
if(op >= 0){
printf("%d", op);
}
else{
char ch;
if(op == -1){ ch = '+'; }
else if(op == -2){ ch = '-'; }
else{ ch = '*'; }
putchar('(');
print();
printf(" %c ", ch);
print();
putchar(')');
}
}
void solve(int i, int S, int oprem, int numrem){
if(i == 6){
for(int j = 0; j < 4; ++j){
if(S >> j & 1){
c[6] = a[j];
}
}
try{
k = 0;
if(calc() == 10 && k == 7){
k = 0;
print();
puts("");
throw "";
}
}catch(int){}
return;
}
if(oprem > 0){
for(int op = -1; op >= -3; --op){
c[i] = op;
solve(i + 1, S, oprem - 1, numrem + 1);
}
}
if(numrem > 0){
for(int j = 0; j < 4; ++j){
if(S >> j & 1){
c[i] = a[j];
solve(i + 1, S ^ 1 << j, oprem, numrem - 1);
}
}
}
}
int main(){
while(1){
for(int i = 0; i < 8; ++i){
c[i] = -9;
}
for(int i = 0; i < 4; ++i){
scanf("%d", &a[i]);
}
if(a[0] == 0){ break; }
try{
solve(0, 15, 3, 0);
puts("0");
}catch(...){}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
泥棒
==
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
風呂敷が耐えられる重さ W、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が W を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
Input
-----
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
```
W
N
v1,w1
v2,w2
:
vN,wN
```
１行目に風呂敷の耐えられる重さを表す整数 W (W ≤ 1,000)、２行目にお宝の数 N (1 ≤ N ≤ 1,000) が与えられます。続く N 行に i 番目のお宝の価値を表す整数 vi (0 ≤ vi ≤ 10,000) とその重さを表す整数 wi (0 ≤ wi ≤ W) の組がそれぞれ１行に与えられます。
W が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
Output
------
各データセットに対して以下のように出力して下さい。
```
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
```
Sample Input
------------
```
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
```
Output for the Sample Input
---------------------------
```
Case 1:
220
49
Case 2:
220
49
```
| #include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <sstream>
#include <vector>
#include <string>
#include <iomanip>
#include <bitset>
#define INF 100000000
#define pb push_back
#define fi first
#define sec second
#define SS stringstream
using namespace std;
typedef pair<int, int> P;
typedef long long int ll;
int w, n;
int t = 0;
int dp[1001][1001];
vector<P> vec;
int rec(int i, int j){
if(dp[i][j] >= 0) return dp[i][j];
int res;
if(i == n) res = 0;
else if(j < vec[i].sec) res = rec(i+1, j);
else res = max(rec(i+1, j), rec(i+1, j-vec[i].sec)+vec[i].fi);
return dp[i][j] = res;
}
int main(){
while(scanf("%d", &w)){
t++;
if(w == 0) break;
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for(int i = 0; i < n; i++){
int temp1, temp2;
char trash;
scanf("%d%c%d", &temp1, &trash, &temp2);
vec.pb(P(temp1, temp2));
}
printf("Case %d:\n", t);
printf("%d\n", rec(0, w));
for(int i = 1; i <= w; i++){
if(rec(0, w-i) != rec(0,w)){
printf("%d\n", w-i+1);
break;
}
}
vec.clear();
}
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const double EPS = 1e-10;
const ll INF = 100000000;
const ll MOD = 1000000007;
struct ITEM {
int v, w;
double x;
bool operator>(const ITEM& right) const {
return x > right.x;
}
} item[1000];
int N, W;
int v[1000], w[1000];
int ans;
int ans2;
void dfs (int pos, int val, int sum, bool flag) {
if (ans < val) {
ans = val;
ans2 = sum;
}
if (ans == val) {
ans2 = min(ans2, sum);
}
if (pos == N) return;
if (flag) {
int _W = W-sum;
double lim = val;
for (int i = pos; i < N; i++) {
if (_W >= item[i].w) {
lim += item[i].v;
_W -= item[i].w;
} else {
lim += _W * item[i].x;
break;
}
}
if (lim+EPS < ans) {
return;
}
}
if (sum+item[pos].w <= W) {
dfs(pos+1, val+item[pos].v, sum+item[pos].w, false);
}
dfs(pos+1, val, sum, true);
}
int main() {
int testcase = 1;
while (cin >> W) {
if (W == 0) break;
ans = 0;
cin >> N;
rep(i,N) {
char tmp;
cin >> item[i].v >> tmp >> item[i].w;
item[i].x = item[i].v / (double)item[i].w;
}
sort(item, item+N, greater<ITEM>());
dfs(0, 0, 0, false);
cout << "Case " << testcase << ":" << endl;
cout << ans << endl;
cout << ans2 << endl;
testcase++;
}
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
泥棒
==
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
風呂敷が耐えられる重さ W、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が W を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
Input
-----
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
```
W
N
v1,w1
v2,w2
:
vN,wN
```
１行目に風呂敷の耐えられる重さを表す整数 W (W ≤ 1,000)、２行目にお宝の数 N (1 ≤ N ≤ 1,000) が与えられます。続く N 行に i 番目のお宝の価値を表す整数 vi (0 ≤ vi ≤ 10,000) とその重さを表す整数 wi (0 ≤ wi ≤ W) の組がそれぞれ１行に与えられます。
W が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
Output
------
各データセットに対して以下のように出力して下さい。
```
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
```
Sample Input
------------
```
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
```
Output for the Sample Input
---------------------------
```
Case 1:
220
49
Case 2:
220
49
```
| #include <iostream>
#include <cstdio>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
int weight;
int n,v,w,c=0;
int dp[1001][1001];
while(scanf("%d\n",&weight) && weight){
c++;
rep(i,1001)rep(j,1001)dp[i][j]=0;
scanf("%d\n",&n);
for(int k=1;k<=n;k++){
scanf("%d,%d\n",&v,&w);
for(int i=0;i<=w;i++){
dp[k][i] = dp[k-1][i];
}
for(int i=w;i<=weight;i++){
dp[k][i] = max(dp[k-1][i],dp[k-1][i-w]+v);
}
}
/*for(int k=0;k<=n;k++){
for(int i=0;i<=weight;i++)
printf("%4d",dp[k][i]);
puts("");
}*/
printf("Case %d:\n",c);
printf("%d\n",dp[n][weight]);
for(int i=0;i<=weight;i++){
if(dp[n][i]==dp[n][weight]){
printf("%d\n",i);
break;
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int,int> &a,const pair<int,int> &b){
if( a.first != b.first ) return a.first < b.first;
else return a.second > b.second;
}
int main(){
int n,W;
int t = 1;
while( cin >> W >> n && W ){
vector< pair<int,int> > cur;
cur.push_back({0,0});
for(int i = 0 ; i < n ; i++){
int w,c;
scanf("%d,%d",&c,&w);
for(int j = 0 , t = cur.size() ; j < t ; j++ )
cur.push_back(pair<int,int>(cur[j].first+w,cur[j].second+c));
sort(cur.begin(),cur.end(),cmp);
int maxi = -1;
vector< pair<int,int> > nex;
for(int j = 0 ; j < cur.size() ; j++){
if( maxi >= cur[j].second ) continue;
if( cur[j].first <= W ) nex.push_back(cur[j]);
maxi = cur[j].second;
}cur = nex;
}
int ans = 0, ans2 ;
for(int i = 0 ; i < cur.size() ; i++){
if( cur[i].first <= W ){
ans = cur[i].second;
ans2 = cur[i].first;
}
}
cout << "Case " << t++ << ":" << endl;
cout << ans << endl;
cout << ans2 << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
泥棒
==
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
風呂敷が耐えられる重さ W、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が W を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
Input
-----
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
```
W
N
v1,w1
v2,w2
:
vN,wN
```
１行目に風呂敷の耐えられる重さを表す整数 W (W ≤ 1,000)、２行目にお宝の数 N (1 ≤ N ≤ 1,000) が与えられます。続く N 行に i 番目のお宝の価値を表す整数 vi (0 ≤ vi ≤ 10,000) とその重さを表す整数 wi (0 ≤ wi ≤ W) の組がそれぞれ１行に与えられます。
W が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
Output
------
各データセットに対して以下のように出力して下さい。
```
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
```
Sample Input
------------
```
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
```
Output for the Sample Input
---------------------------
```
Case 1:
220
49
Case 2:
220
49
```
| #include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
for(int c=1,w; cin>>w,w; c++){
int n,tr[1001][2] = {0};
cin >>n;
for(int i=1; i<=n; i++){
scanf("%d,%d",&tr[i][0],&tr[i][1]);
}
int dp[1001][1001] = {0};
for(int i=1; i<=n; i++){
for(int j=0; j<=w; j++){
if(j>=tr[i][1]){dp[j][i] = max(dp[j][i-1],dp[j-tr[i][1]][i-1]+tr[i][0]);}
else{dp[j][i] = dp[j][i-1];}
}
}
int pr = dp[w][n], val;
for(int j=0; j<=w; j++){
if(pr == dp[j][n]){val = j;break;}
}
cout <<"Case "<<c<<":"<<endl;
cout <<pr<<endl<<val<<endl;
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int w,n,tre[1001][2],dp[1001][1001] = {0},x;
for(int c = 1; cin >>w,w; c++){
cin >>n;
for(int i=1; i<=n; i++){
scanf("%d,%d",&tre[i][0],&tre[i][1]);
}
for(int i=1; i<=n; i++){
for(int j=1; j<=w; j++){
dp[i][j] = dp[i-1][j];
if(j>=tre[i][1]){dp[i][j] = max(dp[i][j],dp[i-1][j-tre[i][1]]+tre[i][0]);}
}
}
for(int j=0; j<=w; j++){
if(dp[n][j] == dp[n][w]){x = j;break;}
}
cout <<"Case "<<c<<":"<<endl<<dp[n][w]<<endl<<x<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
泥棒
==
宝物がたくさん収蔵されている博物館に、泥棒が大きな風呂敷を一つだけ持って忍び込みました。盗み出したいものはたくさんありますが、風呂敷が耐えられる重さが限られており、これを超えると風呂敷が破れてしまいます。そこで泥棒は、用意した風呂敷を破らず且つ最も価値が高くなるようなお宝の組み合わせを考えなくてはなりません。
風呂敷が耐えられる重さ W、および博物館にある個々のお宝の価値と重さを読み込んで、重さの総和が W を超えない範囲で価値の総和が最大になるときの、お宝の価値総和と重さの総和を出力するプログラムを作成してください。ただし、価値の総和が最大になる組み合わせが複数あるときは、重さの総和が小さいものを出力することとします。
Input
-----
複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。
```
W
N
v1,w1
v2,w2
:
vN,wN
```
１行目に風呂敷の耐えられる重さを表す整数 W (W ≤ 1,000)、２行目にお宝の数 N (1 ≤ N ≤ 1,000) が与えられます。続く N 行に i 番目のお宝の価値を表す整数 vi (0 ≤ vi ≤ 10,000) とその重さを表す整数 wi (0 ≤ wi ≤ W) の組がそれぞれ１行に与えられます。
W が 0 のとき入力の最後とします。データセットの数は 50 を超えません。
Output
------
各データセットに対して以下のように出力して下さい。
```
Case データセットの番号:
風呂敷に入れたお宝の価値総和
そのときのお宝の重さの総和
```
Sample Input
------------
```
50
5
60,10
100,20
120,30
210,45
10,4
50
5
60,10
100,20
120,30
210,45
10,4
0
```
Output for the Sample Input
---------------------------
```
Case 1:
220
49
Case 2:
220
49
```
|
// dpの練習
// dpでなく、愚直に組んだプログラミング
// ナップサック問題とほぼ同じ
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int wei; // 持てる最大の重さ
int n; // お宝の数
int v[1001]; // お宝の価値
int w[1001]; // お宝の重さ
// グローバル配列は0で初期化されている
int dp[1001][1001]; //メモテーブル
int max_value(int i, int j) {
int value;
if( dp[i][j] >= 0 ){
return dp[i][j];
//すでに１回は調べている
}
if (i == n) {
// 品物がもう残っていないときは、価値の和の最大値は0で確定
//もうお宝がないつまり、価値は0
value = 0;
} else if (j < w[i]) {
//風呂敷が持てる重さを超えてしまう
// 残りの容量が足りず品物iを入れられないので、入れないパターンだけ処理
// i+1 以降の品物のみを使ったときの最大値をそのままこの場合の最大値にする
value = max_value(i + 1, j);
} else {
//左がお宝を入れない、右がお宝を入れた場合
// 品物iを入れるか入れないか選べるので、両方試して価値の和が大きい方を選ぶ
value = max( max_value(i + 1, j), max_value(i + 1, j - w[i]) + v[i] );
}
return dp[i][j] = value;
//メモに記憶させる
}
void max_weight( int ans ){
int w_min;
for (int i = wei -1 ; i >= 0 ; i--){
if( ans != max_value( 0 , i ) ){
w_min = i + 1;
break;
}
}
cout << w_min << endl;
}
int main(void){
int cnt = 1;
while( cin >> wei ){
memset( dp , -1 , sizeof(dp) );
//まだ調べてないところを-1で初期化
if( wei == 0 )break;
cin >> n;
char ten;
for( int i = 0 ; i < n ; i++ ){
cin >> v[i] >> ten >> w[i];
}
cout << "Case " << cnt << ":" << endl;
int ans = max_value( 0 , wei );
cout << ans << endl;
max_weight(ans);
cnt++;
}
return 0;
} | #include <iostream>
#include <cstring>
#include <algorithm>
#define MAX 1000
using namespace std;
int main(void){
int n,W;
int w[MAX+1];
int v[MAX+1];
int dp[MAX+1][MAX+1];
char ten;
int cnt = 1;
while( cin >> W , W ){
cin >> n;
for( int i = 0 ; i < n ; i++ ){
cin >> v[i] >> ten >> w[i];
}
for( int i = 0 ; i < MAX ; i++ ){
for( int j = 0 ; j < MAX ; j++ ){
dp[i][j] = 0;
}
}
for( int i = 0 ; i < n ; i++ ){
for( int j = 0 ; j <= W ; j++ ){
if(j < w[i] ) dp[i+1][j] = dp[i][j];
else dp[i+1][j] = max( dp[i][j] , dp[i][j-w[i]] + v[i] );
}
}
cout << "Case " << cnt++ << ":" << endl;
for( int i = W ; i >= 0 ; i-- ){
if( dp[n][i] != dp[n][W] ){
cout << dp[n][W] << endl << i+1 << endl;
break;
}
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
島の数
===
地勢を示す縦 12, 横 12 のマスからなる平面図があります。おのおののマスは白か黒に塗られています。白は海を、黒は陸地を表します。二つの黒いマスが上下、あるいは左右に接しているとき、これらは地続きであるといいます。この平面図では、黒いマス一つのみ、あるいは地続きの黒いマスが作る領域を「島」といいます。例えば下図には、5 つの島があります。
```
■■■■□□□□■■■■
■■■□□□□□■■■■
■■□□□□□□■■■■
■□□□□□□□■■■■
□□□■□□□■□□□□
□□□□□□■■■□□□
□□□□□■■■■■□□
■□□□■■■■■■■□
■■□□□■■■■■□□
■■■□□□■■■□□□
■■■■□□□■□□□□
□□□□□□□□□□□□
```
マスのデータを読み込んで、島の数を出力するプログラムを作成してください。
Input
-----
入力は複数のデータセットからなります。各データセットに１つの平面図が与えられます。黒いマスを 1、白いマスを 0 で表現した 12 個の数字の列 12 行でひとつの平面図を表します。データセットの間は１つの空行で区切られています。
データセットの数は 20 を超えません。
Output
------
データセットごとに、島の数を１行に出力します。
Sample Input
------------
```
111100001111
111000001111
110000001111
100000001111
000100010000
000000111000
000001111100
100011111110
110001111100
111000111000
111100010000
000000000000
010001111100
110010000010
010010000001
010000000001
010000000110
010000111000
010000000100
010000000010
010000000001
010010000001
010010000010
111001111100
000000000000
111111111111
100010100001
100010100001
100010100001
100010100001
100100100101
101000011101
100000000001
100000000001
111111111111
100000000001
```
Output for the Sample Input
---------------------------
```
5
13
4
```
Hint
----
以下はサンプルインプットを■と□で表したものです。
```
■■■■□□□□■■■■ □■□□□■■■■■□□ □□□□□□□□□□□□
■■■□□□□□■■■■ ■■□□■□□□□□■□ ■■■■■■■■■■■■
■■□□□□□□■■■■ □■□□■□□□□□□■ ■□□□■□■□□□□■
■□□□□□□□■■■■ □■□□□□□□□□□■ ■□□□■□■□□□□■
□□□■□□□■□□□□ □■□□□□□□□■■□ ■□□□■□■□□□□■
□□□□□□■■■□□□ □■□□□□■■■□□□ ■□□□■□■□□□□■
□□□□□■■■■■□□ □■□□□□□□□■□□ ■□□■□□■□□■□■
■□□□■■■■■■■□ □■□□□□□□□□■□ ■□■□□□□■■■□■
■■□□□■■■■■□□ □■□□□□□□□□□■ ■□□□□□□□□□□■
■■■□□□■■■□□□ □■□□■□□□□□□■ ■□□□□□□□□□□■
■■■■□□□■□□□□ □■□□■□□□□□■□ ■■■■■■■■■■■■
□□□□□□□□□□□□ ■■■□□■■■■■□□ ■□□□□□□□□□□■
```
| #include<cstdio>
#include<iostream>
#include<vector>
#include<string>
#include<deque>
#include<map>
#include<algorithm>
using namespace std;
int masu[14][14];
int cont;
void saiki(int x,int y){
masu[x][y]=0;
if(masu[x+1][y]==1)
saiki(x+1,y);
if(masu[x][y+1]==1)
saiki(x,y+1);
if(masu[x-1][y]==1)
saiki(x,y-1);
if(masu[x][y-1]==1)
saiki(x,y-1);
}
int main(){
while(1){
for(int i=0;i<14;i++){
for(int j=0;j<14;j++){
masu[i][j]=0;
}
}
for(int i=1;i<=12;i++){
char st[13];
if(scanf("%s",st)==EOF){
goto A;
}
for(int j=0;j<12;j++){
if(st[j]=='0'){
masu[i][j+1]=0;
}else{
masu[i][j+1]=1;
}
}
}
cont=0;
for(int i=1;i<=12;i++){
for(int j=1;j<=12;j++){
if(masu[i][j]==1){
cont++;
saiki(i,j);
}
}
}
printf("%d\n",cont);
}
A:;
} | #include<cstdio>
#include<algorithm>
using namespace std;
int masu[14][14];
int cont;
void saiki(int x,int y){
masu[x][y]=0;
if(masu[x+1][y]==1){
saiki(x+1,y);
}
if(masu[x-1][y]==1){
saiki(x-1,y);
}
if(masu[x][y+1]==1){
saiki(x,y+1);
}
if(masu[x][y-1]==1){
saiki(x,y-1);
}
}
int main()
{
while(1){
for(int i=0;i<14;i++){
for(int j=0;j<14;j++)
masu[i][j]=0;
}
cont=0;
char str[100];
for(int i=1;i<=12;i++){
if(scanf("%s",str)==EOF){
goto A;
}
for(int j=1;j<=12;j++){
if(str[j-1]=='1'){
masu[i][j]=1;
}
}
}
for(int i=1;i<=12;i++){
for(int j=1;j<=12;j++){
if(masu[i][j]==1){
saiki(i,j);
cont++;
}
}
}
printf("%d\n",cont);
}
A:;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Combination of Number Sequences
===============================
0 から 9 までの整数を使った n 個の数の並び k1, k2, ..., kn を考えます。正の整数 n と s を読み込んで、
k1 + 2 × k2 + 3 × k3 + ... + n × kn = s
となっているような n 個の数の並びが何通りあるかを出力するプログラムを作成してください。ただし、1 つの「n 個の数の並び」には同じ数が 2 回以上現われないものとします。
Input
-----
入力は複数のデータセットからなります。各データセットとして、n (1 ≤ n ≤ 10) と s (0 ≤ s ≤ 10,000)が空白区切りで１行に与えられます。
データセットの数は 100 を超えません。
Output
------
データセットごとに、n 個の整数の和が s になる組み合わせの個数を１行に出力します。
Sample Input
------------
```
3 10
3 1
```
Output for the Sample Input
---------------------------
```
8
0
```
| #include<cstdio>
using namespace std;
int n,s;
int memo[1024][1000];
int search(int stat,int sum,int dep){
if(dep==n) return memo[stat][sum]=(s==sum);
if(~memo[stat][sum]) return memo[stat][sum];
// if(sum>s) return 0;
int cnt=0;
for(int i=0;i<10;i++){
if((stat&(1<<i))==0){
stat|=1<<i;
cnt+=search(stat,sum+i*(n-dep),dep+1);
stat&=~(1<<i);
}
}
return memo[stat][sum]=cnt;
}
int main(){
for(;~scanf("%d%d",&n,&s);){
for(int i=0;i<1024;i++)for(int j=0;j<1000;j++) memo[i][j]=-1;
if(n>10 || s>=1000){
puts("0");
continue;
}
printf("%d\n",search(0,0,0));
}
return 0;
} | #include<cstdio>
using namespace std;
int n,s,memo[1024][500];
int search(int stat,int sum,int dep){
if(dep==n) return memo[stat][sum]=(s==sum);
if(~memo[stat][sum]) return memo[stat][sum];
if(sum>s) return 0;
int cnt=0;
for(int i=0;i<10;i++){
if((stat&(1<<i))==0){
stat|=1<<i;
cnt+=search(stat,sum+i*(n-dep),dep+1);
stat&=~(1<<i);
}
}
return memo[stat][sum]=cnt;
}
int main(){
for(;~scanf("%d%d",&n,&s);){
for(int i=0;i<1024;i++)for(int j=0;j<500;j++) memo[i][j]=-1;
if(n>10 || s>=500){ puts("0"); continue; }
printf("%d\n",search(0,0,0));
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
３乗根
===
$x^3 = q$ の解は漸化式 $x\_{n+1} = x\_n - \frac{x\_{n}^3 - q}{3x\_{n}^2}$ を計算していくことで近似的に求めることができます。
$x\_1$ に正の数 $\frac{q}{2}$ をいれ
$x\_2 = x\_1 - \frac{x\_{1}^3 - q}{3x\_{1}^2}$、$x\_3 = x\_2 - \frac{x\_{2}^3 - q}{3x\_{2}^2}$、… と計算します。
この計算をしながら、
$|x^3 - q|$ の値が、十分小さくなったところで、計算をやめ、最後に計算した $x\_n$ を $x^3 = q$ の近似解とします。
この方法に従って、入力された正の整数 $q$ に対し、 $q$ の３乗根の近似値を出力するプログラムを作成してください。ただし、「十分小さくなった」という判定は $|x^3 - q| < 0.00001 q$ を用いてください。
入力
--
複数のデータセットが与えられる。各データセットに $q$ ($1 \leq q < 2^{31}$)（整数）が一行に与えられる。入力の終わりは -1 である。
データセットの数は 50 を超えない。
出力
--
各データセットに対して $x$ （実数）を１行に出力する。出力結果に 0.00001 以下の誤差を含んでもよい。
Sample Input
------------
```
15
15
-1
```
Output for the Sample Input
---------------------------
```
2.466212
2.466212
```
| #include <iostream>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
bool eq(double x,double y){
if(abs(x-y)<0.00001*y)return true;
else return false;
}
int main(void){
long long q;
double x[100], x1;
while(cin >> q){
if(q == -1) break;
x[1] = q/2.0;
for(int i = 2; ; i++){
x[i] = x[i-1]-(x[i-1]*x[i-1]*x[i-1]-(double)q)/(3*x[i-1]*x[i-1]);
if(eq(x[i]*x[i]*x[i],(double)q)){
x1 = x[i];
break;
}
}
cout <<fixed;
cout << setprecision(7) << x1 << endl;
}
return 0;
}
| #include <stdio.h>
#include <math.h>
int main(void){
double q;
while(scanf("%lf", &q)!= EOF && q != -1) {
double x, a;
x=q/2;
while(1){
if(fabs(x*x*x-q)<0.00001*q) break;
x=x-((x*x*x-q)/(3*x*x));
x = x;
}
printf("%.7f\n",x);
}
return 0;
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
正方形探索
=====
縦に n 行、横に n 列並べられた、合計 n × n のマス目があります。いくつかのマス目には印がついています。各マス目の印の状態を読み込み、印のついていないマス目だけからなる最大の正方形の辺の長さを出力として表示するプログラムを作成してください。
たとえば各データセットで以下のようなデータが与えられます。
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
```
入力データの一行が、一行のマス目を表現します。入力データの文字列のうち、.（ピリオド）は印のついていないマス目、\*（アスタリスク）は印のついているマス目を示しています。
上記の例では、下図の 0 で示される正方形が最大となります。
```
...*....**
..........
**....**..
...00000*.
..*00000..
...00000..
.*.00000..
...00000..
....*..***
.*....*...
```
よって、5 と出力すれば正解になります。
なお、すべてのマス目に印がついている場合には、0 を出力してください。
Input
-----
上記形式で複数のデータセットが与えられます。
n が 0 のとき入力の最後とします。n は 1000 以下とします。入力データの文字列には、ピリオド、アスタリスク、改行以外の文字は含まれません。データセットの数は 50 を超えません。
Output
------
各データセットに対し、最大の正方形の辺の長さ（整数）を１行に出力して下さい。
Sample Input
------------
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
10
****.*****
*..*.*....
****.*....
*....*....
*....*****
..........
****.*****
*..*...*..
****...*..
*..*...*..
0
```
Output for the Sample Input
---------------------------
```
5
3
```
| #include<cstdio>
#include<iostream>
#define INF 2100000000
using namespace std;
int minix(int a,int b,int c){
if(b>=a && c>=a){
return a;
}
if(a>=b && c>=b){
return b;
}
if(b>=c && a>=c){
return c;
}
}
int main(){
int n;
int masu[1002][1002];
int ura[1002][1002];
char str[1002];
while(1){
for(int i=0;i<=1001;i++){
for(int j=0;j<=1001;j++){
masu[i][j]=0;
}
}
scanf("%d",&n);
if(n==0){
break;
}
for(int i=1;i<=n;i++){
scanf("%s",str);
for(int j=1;j<=n;j++){
if(str[j-1]=='.'){
ura[i][j]=0;
}else{
ura[i][j]=1;
}
}
}
int maxi=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(ura[i][j]==0){
masu[i][j]=minix(masu[i-1][j],masu[i][j-1],masu[i-1][j-1])+1;
maxi=max(masu[i][j],maxi);
}
}
}
printf("%d\n",maxi);
}
} | #include<cstdio>
#include<iostream>
#define INF 2100000000
using namespace std;
int minix(int a,int b,int c){
if(b>=a && c>=a){
return a;
}
if(a>=b && c>=b){
return b;
}
if(b>=c && a>=c){
return c;
}
}
int main(){
int n;
int masu[1002][1002];
int ura[1002][1002];
char str[1002];
while(1){
scanf("%d",&n);
if(n==0){
break;
}
for(int i=1;i<=n;i++){
scanf("%s",str);
for(int j=1;j<=n;j++){
if(str[j-1]=='.'){
ura[i][j]=0;
}else{
ura[i][j]=1;
}
}
}
for(int i=0;i<=n;i++){
masu[i][0]=masu[0][i]=0;
}
int maxi=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(ura[i][j]==0){
masu[i][j]=minix(masu[i-1][j],masu[i][j-1],masu[i-1][j-1])+1;
maxi=max(masu[i][j],maxi);
}else{
masu[i][j]=0;
}
}
}
printf("%d\n",maxi);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
正方形探索
=====
縦に n 行、横に n 列並べられた、合計 n × n のマス目があります。いくつかのマス目には印がついています。各マス目の印の状態を読み込み、印のついていないマス目だけからなる最大の正方形の辺の長さを出力として表示するプログラムを作成してください。
たとえば各データセットで以下のようなデータが与えられます。
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
```
入力データの一行が、一行のマス目を表現します。入力データの文字列のうち、.（ピリオド）は印のついていないマス目、\*（アスタリスク）は印のついているマス目を示しています。
上記の例では、下図の 0 で示される正方形が最大となります。
```
...*....**
..........
**....**..
...00000*.
..*00000..
...00000..
.*.00000..
...00000..
....*..***
.*....*...
```
よって、5 と出力すれば正解になります。
なお、すべてのマス目に印がついている場合には、0 を出力してください。
Input
-----
上記形式で複数のデータセットが与えられます。
n が 0 のとき入力の最後とします。n は 1000 以下とします。入力データの文字列には、ピリオド、アスタリスク、改行以外の文字は含まれません。データセットの数は 50 を超えません。
Output
------
各データセットに対し、最大の正方形の辺の長さ（整数）を１行に出力して下さい。
Sample Input
------------
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
10
****.*****
*..*.*....
****.*....
*....*....
*....*****
..........
****.*****
*..*...*..
****...*..
*..*...*..
0
```
Output for the Sample Input
---------------------------
```
5
3
```
| #include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int n;
int s[1001][1024];
int calc(int y,int x,int n){
int a,b,c,d;
n--;
a=s[y-1][x-1];
b=s[y-1][x+n];
c=s[y+n][x-1];
d=s[y+n][x+n];
return d-c-b+a;
}
int main(){
while(cin>>n,n){
memset(s,0,sizeof(s));
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
char c;
cin>>c;
s[i][j] = (c=='*')+s[i-1][j]+s[i][j-1]-s[i-1][j-1];
}
}
int ans=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
int lb=0,ub=n-max(i,j)+2;
while(ub-lb>1){
int m=(lb+ub)/2;
if(calc(i,j,m))ub=m;
else lb=m;
}
ans=max(ans,lb);
}
}
cout<<ans<<endl;
}
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int n;
int s[1001][1024];
int calc(int y,int x,int n){
int a,b,c,d;
n--;
a=s[y-1][x-1];
b=s[y-1][x+n];
c=s[y+n][x-1];
d=s[y+n][x+n];
return d-c-b+a;
}
int main(){
while(cin>>n,n){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
char c;
cin>>c;
s[i][j] = (c=='*')+s[i-1][j]+s[i][j-1]-s[i-1][j-1];
}
}
int ans=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
int lb=ans,ub=n-max(i,j)+2;
if(ub+1<=ans)continue;
while(ub-lb>1){
int m=(lb+ub)/2;
if(calc(i,j,m))ub=m;
else lb=m;
}
ans=max(ans,lb);
}
}
cout<<ans<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
正方形探索
=====
縦に n 行、横に n 列並べられた、合計 n × n のマス目があります。いくつかのマス目には印がついています。各マス目の印の状態を読み込み、印のついていないマス目だけからなる最大の正方形の辺の長さを出力として表示するプログラムを作成してください。
たとえば各データセットで以下のようなデータが与えられます。
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
```
入力データの一行が、一行のマス目を表現します。入力データの文字列のうち、.（ピリオド）は印のついていないマス目、\*（アスタリスク）は印のついているマス目を示しています。
上記の例では、下図の 0 で示される正方形が最大となります。
```
...*....**
..........
**....**..
...00000*.
..*00000..
...00000..
.*.00000..
...00000..
....*..***
.*....*...
```
よって、5 と出力すれば正解になります。
なお、すべてのマス目に印がついている場合には、0 を出力してください。
Input
-----
上記形式で複数のデータセットが与えられます。
n が 0 のとき入力の最後とします。n は 1000 以下とします。入力データの文字列には、ピリオド、アスタリスク、改行以外の文字は含まれません。データセットの数は 50 を超えません。
Output
------
各データセットに対し、最大の正方形の辺の長さ（整数）を１行に出力して下さい。
Sample Input
------------
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
10
****.*****
*..*.*....
****.*....
*....*....
*....*****
..........
****.*****
*..*...*..
****...*..
*..*...*..
0
```
Output for the Sample Input
---------------------------
```
5
3
```
| #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
int dp[1001][1001];
int latte(int i,int j,int k){
return dp[i+k][j+k]-dp[i+k][j-1]-dp[i-1][j+k]+dp[i-1][j-1];
}
int main(){
int n;
while(cin>>n,n){
fill(dp[0],dp[0]+1001*1001,0);
for(int i=0;i<n;i++){
string str;
cin>>str;
for(int j=0;j<n;j++){
dp[i+1][j+1]=dp[i][j+1]+dp[i+1][j]-dp[i][j];
if(str[j]=='*')dp[i+1][j+1]++;
}
}
int Max=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(latte(i,j,0))continue;
int lb=0,ub=min(n-i,n-j)+1;
while(ub-lb>1){
int k=(ub+lb)/2;
//if(i+k>n||j+k>n)ub=k;
if(latte(i,j,k))ub=k;
else lb=k;
}
Max=max(Max,lb+1);
}
}
cout<<Max<<endl;
}
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
while(scanf("%d",&n),n){
int dp[2][1010]={{0}};
int ma=0;
for(int i=0;i<n;i++){
char str[1010];
scanf("%s",str);
for(int j=0;j<n;j++){
if(str[j]=='*')dp[(i+1)&1][j+1]=0;
else{
dp[(i+1)&1][j+1]=min(dp[i&1][j],min(dp[(i+1)&1][j],dp[i&1][j+1]))+1;
}
ma=max(ma,dp[(i+1)&1][j+1]);
}
}
printf("%d\n",ma);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
正方形探索
=====
縦に n 行、横に n 列並べられた、合計 n × n のマス目があります。いくつかのマス目には印がついています。各マス目の印の状態を読み込み、印のついていないマス目だけからなる最大の正方形の辺の長さを出力として表示するプログラムを作成してください。
たとえば各データセットで以下のようなデータが与えられます。
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
```
入力データの一行が、一行のマス目を表現します。入力データの文字列のうち、.（ピリオド）は印のついていないマス目、\*（アスタリスク）は印のついているマス目を示しています。
上記の例では、下図の 0 で示される正方形が最大となります。
```
...*....**
..........
**....**..
...00000*.
..*00000..
...00000..
.*.00000..
...00000..
....*..***
.*....*...
```
よって、5 と出力すれば正解になります。
なお、すべてのマス目に印がついている場合には、0 を出力してください。
Input
-----
上記形式で複数のデータセットが与えられます。
n が 0 のとき入力の最後とします。n は 1000 以下とします。入力データの文字列には、ピリオド、アスタリスク、改行以外の文字は含まれません。データセットの数は 50 を超えません。
Output
------
各データセットに対し、最大の正方形の辺の長さ（整数）を１行に出力して下さい。
Sample Input
------------
```
10
...*....**
..........
**....**..
........*.
..*.......
..........
.*........
..........
....*..***
.*....*...
10
****.*****
*..*.*....
****.*....
*....*....
*....*****
..........
****.*****
*..*...*..
****...*..
*..*...*..
0
```
Output for the Sample Input
---------------------------
```
5
3
```
|
#include <stdio.h>
#include <queue>
using namespace std;
int ifield[1001][1001] = {0};
int main()
{
queue<int> x,y,longth;
int n,memlongth,ans;
int dx1[9] = {-1,-1,-1,0,0,0,1,1,1},dy1[9] = {-1,0,1,-1,0,1,-1,0,1},dx2[3] = {1,0,1},dy2[3] = {0,1,1};
while(1)
{
memlongth = 0;
char cfield[1010][1010] = {0},N;
scanf("%d",&n);
if(n == 0)return 0;
scanf("%c",&N);
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n + 1; j++)
{
ifield[j][i] = 0;
}
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n + 1; j++)
{
scanf("%c",&cfield[j][i]);
if(cfield[j][i] == '*')
{
x.push(j);
y.push(i);
longth.push(0);
ifield[j][i] = 9;
}
}
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
if(ifield[j][i] == 0 && (i == 0 || i == n - 1 || j == 0 || j == n - 1))
{
ifield[j][i] = 1;
x.push(j);
y.push(i);
longth.push(1);
memlongth = 1;
}
}
}
while(x.size())
{
for(int i = 0; i < 9; i++)
{
if(0 <= x.front() + dx1[i] && x.front() + dx1[i] < n &&
0 <= y.front() + dy1[i] && y.front() + dy1[i] < n &&
ifield[x.front() + dx1[i]][y.front() + dy1[i]] == 0)
{
ifield[x.front() + dx1[i]][y.front() + dy1[i]] = longth.front() + 1;
x.push(x.front() + dx1[i]);
y.push(y.front() + dy1[i]);
longth.push(longth.front() + 1);
memlongth = longth.front() + 1;
}
}
x.pop();
y.pop();
longth.pop();
}
if(memlongth == 0)ans = 0;
else ans = memlongth * 2 - 1;
for(int i = 0; i < n - 1; i++)
{
for(int j = 0; j < n - 1; j++)
{
if(ifield[j][i] == memlongth)
{
for(int k = 0; k < 3; k++)
{
if(ifield[j + dx2[k]][i + dy2[k]] == memlongth);
else break;
if(k == 2)ans = memlongth * 2;
}
}
}
}
printf("%d\n",ans);
}
} | #include<stdio.h>
#include<algorithm>
using namespace std;
int main()
{
int n,ans = 0;
int dp[1100][1100];
char field;
while(scanf("%d",&n),n)
{
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
{
scanf(" %c",&field);
dp[j + 1][i + 1] = 0;
if(field == '*')dp[j + 1][i + 1] = -1;
}
for(int i = 1; i < n + 1; i++)
{
for(int j = 1; j < n + 1; j++)
{
if(dp[j][i] == -1);
else if(j == 1 || i == 1)dp[j][i] = 1;
else dp[j][i] = max(1,min(dp[j - 1][i - 1],min(dp[j - 1][i],dp[j][i - 1])) + 1);
ans = max(ans,dp[j][i]);
}
}
/*for(int i = 1; i < n + 1; i++)
{
for(int j = 1; j < n + 1; j++)
{
printf("%2d",dp[j][i]);
}
printf("\n");
}*/
printf("%d\n",ans);
ans = 0;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Sale Result
===========
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID *i*, the amount of sales *q* and the corresponding unit price *p*. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that *n* < 4000, and each employee has an unique ID. The unit price *p* is less than or equal to 1,000,000 and the amount of sales *q* is less than or equal to 100,000.
Input
-----
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
```
n (the number of data in the list)
i p q
i p q
:
:
i p q
```
Output
------
For each dataset, print a list of employee IDs or a text "NA"
Sample Input
------------
```
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
```
Output for the Sample Input
---------------------------
```
1001
1003
NA
2013
```
| #include <iostream>
#include <map>
#include <vector>
using namespace std;
int main(){
int n,a,b;
bool flag;
string number;
map<string,int> info;
vector<string> seq;
while(cin >> n && n){
info.clear();
seq.clear();
while(n--){
cin >> number >> a >> b;
if(!info[number])seq.push_back(number);
while(b-- && info[number]<1000000){
info[number] += a;
}
}
flag = true;
for(int i=0;i<seq.size();i++){
if(info[seq[i]]>=1000000){
flag = false;
cout << seq[i] << endl;
}
}
if(flag)cout << "NA" << endl;
}
} | #include <iostream>
#include <map>
#include <vector>
using namespace std;
int main(){
long long n,a,b;
bool flag;
int number;
map<int,long long> info;
vector<int> seq;
while(cin >> n && n){
info.clear();
seq.clear();
while(n--){
cin >> number >> a >> b;
if(!info[number])seq.push_back(number);
info[number] += a*b;
}
flag = true;
for(int i=0;i<seq.size();i++){
if(info[seq[i]]>=1000000){
flag = false;
cout << seq[i] << endl;
}
}
if(flag)cout << "NA" << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Sale Result
===========
There is data on sales of your company. Your task is to write a program which identifies good workers.
The program should read a list of data where each item includes the employee ID *i*, the amount of sales *q* and the corresponding unit price *p*. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that *n* < 4000, and each employee has an unique ID. The unit price *p* is less than or equal to 1,000,000 and the amount of sales *q* is less than or equal to 100,000.
Input
-----
The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:
```
n (the number of data in the list)
i p q
i p q
:
:
i p q
```
Output
------
For each dataset, print a list of employee IDs or a text "NA"
Sample Input
------------
```
4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0
```
Output for the Sample Input
---------------------------
```
1001
1003
NA
2013
```
| #include <iostream>
#include <string>
using namespace std;
typedef struct{
string id;
long long sales;
} staff;
int main(void)
{
long long n;
while(cin>>n){
if(!n) break;
staff staff1[4001];
int pt = 0;
for(int i=0; i< n; i++){
string id;
cin >> id;
long long price;
int bnum;
cin >> price >> bnum;
int m=-1;
for(int j=0;j < i; j++){
if(id==staff1[j].id){
pt++;
m=j;
break;
}
}
if(m==-1){
staff1[i-pt].id = id;
staff1[i-pt].sales = price * bnum;
}else{
staff1[m].sales += price * bnum;
}
}
int count = 0;
for(int i=0; i < n-pt; i++){
if(staff1[i].sales >= 1000000){
count++;
cout << staff1[i].id << endl;
}
}
if(!count) cout << "NA" << endl;
}
return 0;
} | #include<iostream>
#include<map>
#include<vector>
#include<string>
using namespace std;
#define mp make_pair
int main(){
int n;
string a;
long long b,c;
map<string,long long> data;
vector<string> id;
while(true){
id.clear();
data.clear();
cin>>n;
if(!n)
break;
for(int i=0;i<n;i++){
cin>>a>>b>>c;
c*=b;
if(data.find(a)==data.end()){
data.insert(mp(a,c));
id.push_back(a);
}
else{
data[a]+=c;
}
}
bool empty = true;
for(int i=0;i<id.size();i++){
if(data[id[i]]>=1000000){
cout<<id[i]<<endl;
empty = false;
}
}
if (empty)
cout<<"NA"<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Discounts of Buckwheat
======================
Aizu is famous for its buckwheat. There are many people who make buckwheat noodles by themselves.
One day, you went shopping to buy buckwheat flour. You can visit three shops, A, B and C. The amount in a bag and its unit price for each shop is determined by the follows table. Note that it is discounted when you buy buckwheat flour in several bags.
| | Shop A | Shop B | Shop C |
| --- | --- | --- | --- |
| Amount in a bag | 200g | 300g | 500g |
| Unit price for a bag (nominal cost) | 380 yen | 550 yen | 850 yen |
| Discounted units | per 5 bags | per 4 bags | per 3 bags |
| Discount rate | reduced by 20 % | reduced by 15 % | reduced by 12 % |
For example, when you buy 12 bags of flour at shop A, the price is reduced by 20 % for 10 bags, but not for other 2 bags. So, the total amount shall be (380 × 10) × 0.8 + 380 × 2 = 3,800 yen.
Write a program which reads the amount of flour, and prints the lowest cost to buy them. Note that you should buy the flour of exactly the same amount as the given input.
Input
-----
The input consists of multiple datasets. For each dataset, an integer a (500 ≤ a ≤ 5000, a is divisible by 100) which represents the amount of flour is given in a line.
The input ends with a line including a zero. Your program should not process for the terminal symbol. The number of datasets does not exceed 50.
Output
------
For each dataset, print an integer which represents the lowest cost.
Sample Input
------------
```
500
2200
0
```
Output for the Sample Input
---------------------------
```
850
3390
```
| #include <iostream>
using namespace std;
int soba[][2] = {
{200, 380},
{300, 550},
{500, 850}
};
int main() {
int n, m = 5000 * 500;
cin >> n;
if (n == 0){
return 0;
}
for (int i = n / soba[2][0] + 100; i >= 0; i--) {
for (int j = n / soba[1][0] + 100; j >= 0; j--) {
for (int k = n / soba[0][0] + 100; k >= 0; k--) {
int w = i * soba[2][0] + j * soba[1][0] + k * soba[0][0];
if (w == n) {
int p = (i / 3 * 3 * soba[2][1] * 0.88) + (i % 3 * soba[2][1]) + (j / 4 * 4 * soba[1][1] * 0.85) + (j % 4 * soba[1][1]) + (k / 5 * 5 * soba[0][1] * 0.8) + (k % 5 * soba[0][1]);
if (p < m) {
m = p;
}
}
}
}
}
cout << m << endl;
return main();
} | #include <iostream>
using namespace std;
int soba[][2] = {
{200, 380},
{300, 550},
{500, 850}
};
int main() {
int n, m = 5000 * 500;
cin >> n;
if (n == 0){
return 0;
}
for (int i = n / soba[2][0]; i >= 0; i--) {
for (int j = n / soba[1][0]; j >= 0; j--) {
for (int k = n / soba[0][0]; k >= 0; k--) {
int w = i * soba[2][0] + j * soba[1][0] + k * soba[0][0];
if (w == n) {
int p = (i / 3 * 3 * soba[2][1] * 0.88) + (i % 3 * soba[2][1]) + (j / 4 * 4 * soba[1][1] * 0.85) + (j % 4 * soba[1][1]) + (k / 5 * 5 * soba[0][1] * 0.8) + (k % 5 * soba[0][1]);
if (p < m) {
m = p;
}
}
}
}
}
cout << m << endl;
return main();
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ミルクショップ
=======
鈴木さんは会津地域に新しく搾りたてミルクの移動販売のお店を開きました。その日買い求めに来るお客さんは全員持ち帰るためのボトルを持って既にお店に並んでいて、それ以上増えないものとします。お客さんはそれぞれ1回だけしか注文しません。タンクの蛇口が一つしかないので、一人ずつ順番に販売しなければなりません。そこで、鈴木さんはなるべく並んでいるお客さんの待ち時間を少なくしたいと考えています。
お客さんの人数とお客さんが牛乳を注ぎきるのに要する時間が入力として与えられます。あなたはお客さんの「一人一人の待ち時間の合計」(以下「待ち時間の合計」とする)を最小にするための注文の順序を鈴木さんに代わって調べ、そのときの「待ち時間の合計」を出力して終了するプログラムを作成してください。ただし、お客さんは 10,000 人以下で 1 人あたりに要する時間は 60 分以下とします。
例えば、お客さんの人数が 5 人で、各お客さんが要する時間が順に 2,6,4,3,9 分の場合、そのままの順序だと「待ち時間の合計」は 37 分になります。次の例では、最初の列の順の 2 人目と 3 人目を入れ替えています。この場合、「待ち時間の合計」は 35 分になります。最適な順序だと 31 分で済みます。
| | 待ち時間 | |
| --- | --- | --- |
| 1 人目 2 分 | 0 分 | |
| 2 人目 6 分 | 2 分 | |
| 3 人目 4 分 | 8 分 | |
| 4 人目 3 分 | 12 分 | |
| 5 人目 9 分 | 15 分 | |
| | 37 分 | ← 「待ち時間の合計」 |
2 人目と 3 人目を入れ替えた例
| | 待ち時間 | |
| --- | --- | --- |
| 1 人目 2 分 | 0 分 | |
| 2 人目 4 分 | 2 分 | |
| 3 人目 6 分 | 6 分 | |
| 4 人目 3 分 | 12 分 | |
| 5 人目 9 分 | 15 分 | |
| | 35 分 | ← 「待ち時間の合計」 |
Input
-----
複数のデータセットが与えられます。各データセットは以下の形式で与えられます。
```
n
t1
t2
:
tn
```
1 行目にお客さんの人数 n (n ≤ 10,000) が与えられます。続く n 行に i 人目のお客さんが要する時間を表す整数 ti (0 ≤ ti ≤ 60) がそれぞれ１行に与えられます。
入力は１つの 0 を含む行で終わります。データセットの数は 50 を超えません。
Output
------
各データセットごとに、待ち時間の合計(整数)を１行に出力してください。
Sample Input
------------
```
5
2
6
4
3
9
0
```
Output for the Sample Input
---------------------------
```
31
```
| #include<list>
#include<iostream>
using namespace std;
int main(){
int i;
int n;
long long c;
for(;;){
cin>>n;
if(n==0)
break;
list<int> t;
c=0;
for(i=0;i<n;i++){
int tmp;
cin>>tmp;
t.push_back(tmp);
}
t.sort();
list<int>::iterator it=t.begin();
for(i=0;i<n-1;i++){
c+=(*it)*(n-i-1);
it++;
}
cout<<c<<endl;
}
return 0;
} | #include<algorithm>
#include<cstdio>
using namespace std;
int main(){
int i;
int n;
while(scanf("%d",&n),n){
int a[10000];
for(i=0;i<n;++i)
scanf("%d",a+i);
sort(a,a+n);
long long sm=0;
for(i=0;i<n-1;++i)
sm+=a[i]*(n-i-1);
printf("%lld\n",sm);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
電子蝿
===
ある計算機学者が電子空間に棲息する電子蝿という奇妙な生命体を見つけました。電子蝿の行動を観察しているうちに、この空間の (x, y, z) 地点にいる電子蝿は、次に以下の規則で示される (x', y', z')に移動することが分かりました。
ただし、a1, m1, a2, m2, a3, m3 は電子蝿の個体ごとに定まる正の整数です。A mod B は正の整数 A を正の整数 B で割ったときの余りです。
さらに観察をすると、ある種の電子蝿は (1,1,1) に置いてからしばらくすると、必ず (1,1,1) に戻ってくることがわかりました。このような蝿を戻り蝿と名付けました(1) 。
戻り蝿のデータを入力とし、(1,1,1) に戻ってくる最小の移動回数 (>0) を出力するプログラムを作成してください。なお 1< a1, m1, a2, m2, a3, m3 < 215 とします。
(1) a1 と m1, a2 と m2, a3 と m3 がそれぞれ互いに素 (公約数が 1) である時に戻ります。
Input
-----
複数のデータセットが与えられます。各データセットは以下の形式で与えられます。
```
a1 m1 a2 m2 a3 m3
```
入力は６つの 0 を含む行で終わります。データセットの数は 50 を超えません。
Output
------
各データセットごとに、(1,1,1) に戻ってくる最小の移動回数(整数)を１行に出力してください。
Sample Input
------------
```
2 5 3 7 6 13
517 1024 746 6561 4303 3125
0 0 0 0 0 0
```
Output for the Sample Input
---------------------------
```
12
116640000
```
| #include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
long long int gcd(long long int a, long long int b){
if(b == 0)return a;
return gcd(b,a % b);
}
long long int lcm(long long int a, long long int b){
return a * b / gcd(a,b);
}
int main(){
long long int a[3], m[3], p[3] = {1,1,1}, c[3] = {0};
while(1){
memset(c,0,sizeof(c));
cin >> a[0] >> m[0] >> a[1] >> m[1] >> a[2] >> m[2];
if(!a[0])break;
for(int i=0;i<3;i++){
do{
p[i] = (a[i] * p[i]) % m[i];
//cout << "Turn " << c[i] << ": " << p[i] << endl;
c[i] += 1;
}while(p[i] != 1);
}
//cout << c[0] << c[1] << c[2] << endl;
//int gcd = rec(c[0],rec(c[1],c[2])),
//lcm = rec(c[0],gcd) * rec(c[1],gcd) * rec(c[2],gcd) * gcd;
//cout << gcd << " " << lcm << endl;
cout << lcm(lcm(c[0],c[1]),c[2]) << endl;
}
return 0;
} | #include <cstdio>
#include <cstring>
long long gcd(long long a, long long b){
return b?gcd(b,a % b):a;
}
long long lcm(long long a, long long b){
return a * b / gcd(a,b);
}
int main(){
int a[3], m[3], p[3] = {1,1,1}, c[3] = {0};
while(scanf("%d%d%d%d%d%d",a,m,a+1,m+1,a+2,m+2),a[0]){
memset(c,0,sizeof(c));
for(int i=0;i<3;i++){
do{
p[i] = a[i] * p[i] % m[i];
c[i]++;
}while(p[i] != 1);
}
printf("%lld\n",lcm(lcm(c[0],c[1]),c[2]));
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
長方形探索
=====
縦に H 行、横に W 列並べられた、合計 W × H のマス目があります。いくつかのマス目には印がついています。各マス目の印の状態を読み込み、印のついていないマス目だけからなる最大の長方形の面積を出力するプログラムを作成してください。
入力データは 1 行 W 文字から構成され、H 行が与えられます。たとえば以下のようなデータが与えられます。
```
..*....**.
..........
**....***.
....*.....
..*.......
...**.....
.*.*......
..........
..**......
.*..*.....
```
入力データの一行が、一行のマス目を表現します。入力データの文字列のうち、. (ピリオド) は印のついていないマス目、\* (アスタリスク) は印のついているマス目を示しています。入力データの文字列には、ピリオド、アスタリスク、改行以外の文字は含まれません。
上記の例では、下図の 0 で示される長方形が最大となります。
```
..*....**.
..........
**....***.
....*00000
..*..00000
...**00000
.*.*.00000
.....00000
..**.00000
.*..*00000
```
よって、35 と出力すれば正解になります。なお、すべてのマス目に印がついている場合には、0 を出力してください。
Input
-----
複数のデータセットが与えられます。各データセットはスペースで区切られた H と W からなる行から始まり、つづいて H × W の長方形が与えられます。H, W はともに 500 以下とします。
入力は２つの 0 を含む行で終わります。データセットの数は 20 を超えません。
Output
------
各データセットごとに、最大の長方形の面積を１行に出力してください。
Sample Input
------------
```
10 10
...*....**
..........
**....**..
........*.
..*.......
**........
.*........
..........
....*..***
.*....*...
10 10
..*....*..
.*.*...*..
*****..*..
*...*..*..
*...*..*..
..........
****.*...*
..*..*...*
.*...*...*
****..***.
2 3
...
...
0 0
```
Output for the Sample Input
---------------------------
```
28
12
6
```
| #include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <utility>
#define YNUM(X) ( X < 0 ? X + 3 : X )
typedef std::pair<int, int> WH;
typedef std::vector<WH> whvec;
int main(){
int h, w;
while( std::cin >> h >> w, w + h != 0 ){
bool map[502][502];
std::string in;
std::vector<std::vector<whvec> > data(3, std::vector<whvec>(502));
int data_max = 0;
int height_sum[502][502], width_sum[502][502];
WH wh;
memset( map, 0, sizeof(map) );
memset( height_sum, 0, sizeof(height_sum) );
memset( width_sum, 0, sizeof(width_sum) );
for( int i = 1; i <= h; ++i ){
std::cin >> in;
for( int l = 1; l <= w; ++l ){
map[i][l] = ( in[l - 1] == '.' );
}
}
for( int i = 1; i <= h; ++i ){
for( int l = 1; l <= w; ++l ){
if(map[i][l]){
width_sum[i][l] = width_sum[i][l - 1] + 1;
height_sum[i][l] = height_sum[i - 1][l] + 1;
}
}
}
for( int i = 1, n = 1; n <= h; n++, i = n % 3 ){
data[i] = std::vector<whvec>(502);
for( int l = 1; l <= w; l++ ){
if( map[n][l] ){
if( map[n - 1][l] && map[n][l - 1] ){
int x_cnt = width_sum[n][l], y_cnt = height_sum[n][l];
for( int m = 0; m < data[YNUM(i - 1)][l].size(); ++m ){
wh = WH( std::min(data[YNUM(i - 1)][l][m].first, x_cnt), data[YNUM(i - 1)][l][m].second + 1 );
if( std::find( data[i][l].begin(), data[i][l].end(), wh ) == data[i][l].end() ){
data[i][l].push_back( wh );
data_max = std::max( data_max, wh.first * wh.second );
}
}
for( int m = 0; m < data[i][l - 1].size(); ++m ){
wh = WH( data[i][l - 1][m].first + 1, std::min(data[i][l - 1][m].second, y_cnt) );
if( std::find( data[i][l].begin(), data[i][l].end(), wh ) == data[i][l].end() ){
data[i][l].push_back( wh );
data_max = std::max( data_max, wh.first * wh.second );
}
}
}else if( map[n - 1][l] ){
for( int m = 0; m < data[YNUM(i - 1)][l].size(); ++m ){
data[i][l].push_back( wh = WH( 1, data[YNUM(i - 1)][l][m].second + 1 ) );
data_max = std::max( data_max, wh.first * wh.second );
}
}else if( map[n][l - 1] ){
for( int m = 0; m < data[i][l - 1].size(); ++m ){
data[i][l].push_back( wh = WH( data[i][l - 1][m].first + 1, 1 ) );
data_max = std::max( data_max, wh.first * wh.second );
}
}else data[i][l].push_back( wh = WH( 1, 1 ) ), data_max = std::max( data_max, wh.first * wh.second );
}
}
}
std::cout << data_max << std::endl;
}
return 0;
} | #include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <utility>
#define YNUM(X) ( X < 0 ? X + 3 : X )
typedef std::pair<int, int> WH;
//typedef std::vector<WH> whvec;
int h, w;
bool map[502][502];
std::string in;
//std::vector<std::vector<whvec> > data(3, std::vector<whvec>(502));
WH data[3][502][500];
int data_max = 0;
int height_sum[502][502], width_sum[502][502];
int data_pt[3][502];
WH wh;
int main(){
while( std::cin >> h >> w, w + h != 0 ){
data_max = 0;
memset( data_pt, 0, sizeof(data_pt) );
memset( height_sum, 0, sizeof(height_sum) );
memset( width_sum, 0, sizeof(width_sum) );
for( int i = 1; i <= h; ++i ){
std::cin >> in;
for( int l = 1; l <= w; ++l ){
map[i][l] = ( in[l - 1] == '.' );
if(map[i][l]){
width_sum[i][l] = width_sum[i][l - 1] + 1;
height_sum[i][l] = height_sum[i - 1][l] + 1;
}
}
}
for( int i = 1, n = 1; n <= h; n++, i = n % 3 ){
for( int l = 1; l <= w; l++ ){
data_pt[i][l] = 0;
if( map[n][l] ){
if( map[n - 1][l] && map[n][l - 1] ){
int x_cnt = width_sum[n][l], y_cnt = height_sum[n][l];
for( int m = 0; m < data_pt[YNUM(i - 1)][l]; ++m ){
wh = WH( std::min(data[YNUM(i - 1)][l][m].first, x_cnt), data[YNUM(i - 1)][l][m].second + 1 );
if( std::find( data[i][l], data[i][l] + data_pt[i][l], wh ) == data[i][l] + data_pt[i][l] ){
data[i][l][ data_pt[i][l] ] = wh, data_pt[i][l]++;
data_max = std::max( data_max, wh.first * wh.second );
}
}
for( int m = 0; m < data_pt[i][l - 1]; ++m ){
wh = WH( data[i][l - 1][m].first + 1, std::min(data[i][l - 1][m].second, y_cnt) );
if( std::find( data[i][l], data[i][l] + data_pt[i][l], wh ) == data[i][l] + data_pt[i][l] ){
data[i][l][ data_pt[i][l] ] = wh, data_pt[i][l]++;
data_max = std::max( data_max, wh.first * wh.second );
}
}
}else if( map[n - 1][l] ){
for( int m = 0; m < data_pt[YNUM(i - 1)][l]; ++m ){
data[i][l][ data_pt[i][l] ] = (wh = WH( 1, data[YNUM(i - 1)][l][m].second + 1 )), data_pt[i][l]++;
data_max = std::max( data_max, wh.first * wh.second );
}
}else if( map[n][l - 1] ){
for( int m = 0; m < data_pt[i][l - 1]; ++m ){
data[i][l][ data_pt[i][l] ] = (wh = WH( data[i][l - 1][m].first + 1, 1 )), data_pt[i][l]++;
data_max = std::max( data_max, wh.first * wh.second );
}
}else data[i][l][ data_pt[i][l] ] = (wh = WH( 1, 1 )), data_pt[i][l]++, data_max = std::max( data_max, wh.first * wh.second );
}
}
}
std::cout << data_max << std::endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
#include<iostream>
#include<vector>
#include<sstream>
#include<cmath>
using namespace std;
const int MAX = 13;
vector<double> Cake;
double box;
double dp[(1<<MAX)][MAX];
void init(){
Cake.clear();
fill(dp[0],dp[0]+(1<<MAX)*MAX,100000000);
dp[0][0] = 0;
}
void make(){
string s;
getline(cin,s);
stringstream ss(s);
double num;
while(ss >> num) Cake.push_back(num);
}
void solve(){
for(int i = 0; i < (1<<Cake.size()); i++)
for(int j = 0; j < (int)Cake.size(); j++){
if(i == 0) {dp[(1<<j)][j] = Cake[j]; continue;}
for(int k = 0; k < (int)Cake.size(); k++)
if(!(i&(1<<k)) && j != k){
dp[i+(1<<k)][k] = min(dp[i+(1<<k)][k],dp[i][j]+2.0*sqrt(Cake[j]*Cake[k]));
// if(dp[i][j] == 0) cout << "error" << endl;
}
}
for(int i = 0; i < (int)Cake.size(); i++){
// cout << "cake " << Cake[i] << endl;
//cout << dp[(1<<Cake.size())-1][i]+Cake[i] << endl;
if(dp[(1<<Cake.size())-1][i]+Cake[i] <= box) {cout << "OK" << endl;return;}
}
cout << "NA" << endl;
}
int main(){
while(cin >> box){
init();
make();
solve();
}
return 0;
} | #include<iostream>
#include<vector>
#include<sstream>
#include<cmath>
using namespace std;
const int MAX = 12;
vector<double> Cake;
double box;
double dp[(1<<MAX)][MAX];
void init(){
Cake.clear();
fill(dp[0],dp[0]+(1<<MAX)*MAX,100000000);
dp[0][0] = 0;
}
void make(){
string s;
getline(cin,s);
stringstream ss(s);
double num;
while(ss >> num) Cake.push_back(num);
}
void solve(){
for(int i = 0; i < (1<<Cake.size()); i++)
for(int j = 0; j < (int)Cake.size(); j++){
if(i == 0) {dp[(1<<j)][j] = Cake[j]; continue;}
for(int k = 0; k < (int)Cake.size(); k++)
if(!(i&(1<<k)) && j != k)
dp[i+(1<<k)][k] = min(dp[i+(1<<k)][k],dp[i][j]+2.0*sqrt(Cake[j]*Cake[k]));
}
for(int i = 0; i < (int)Cake.size(); i++){
if(dp[(1<<Cake.size())-1][i]+Cake[i] <= box) {cout << "OK" << endl;return;}
}
cout << "NA" << endl;
}
int main(){
while(cin >> box){
init();
make();
solve();
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN | |
博士の光電管
======
博士 : ピーター君。やったよ。
ピーター : またですか。今度はどんなくだらない発明ですか。
博士 : あの幻の素粒子アキシオンの検出器を発明したんじゃ。
ピーター : アキシオンといえば、欧州合同原子核研究機構 (CERN) をはじめとする研究者たちが血眼で追っかけているという、あれですよね。本当ですかぁ?
博士 : 本当だってばよ。細かい説明は省くが、非常に強力な磁場を内蔵する特殊な光電管が光ることによって、通過するアキシオンを検出する。
ピーター : 他 に先んじて検出すれば、小柴先生のニュートリノ検出に匹敵するノーベル賞級の研究ですよ。
これで役立たずの研究ばかりしている「ダメ研究室」などという汚名も返上できますね。
博士 : そうだとも。小柴先生の「スーパーカミオカンデ」にあやかって、この装置を、(悪口言ったら)「タダジャオカンデ」と命名した。
ピーター : ちょっと苦しいって言うか、卑屈って言うか・・・。
博士 : それはいいとして、この装置ちょっとした癖があるんじゃよ。
アキシオン粒子がある光電管を通過すると、感度の関係でその光電管と隣接する上下左右の光電管が反応する。
| 図1 | | 図2 |
| --- | --- | --- |
| | | ★ | ● | ● | ● | ● | | --- | --- | --- | --- | --- | | ● | ● | ● | ★ | ● | | ● | ● | ● | ● | ● | | ● | ● | ● | ● | ● | | ● | ● | ★ | ● | ● | | | | | --- | | | | → | | | | | | | ○ | ○ | ● | ○ | ● | | --- | --- | --- | --- | --- | | ○ | ● | ○ | ○ | ○ | | ● | ● | ● | ○ | ● | | ● | ● | ○ | ● | ● | | ● | ○ | ○ | ○ | ● | | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | | | | ● | ○ | ○ | ● | ○ | | --- | --- | --- | --- | --- | | ○ | ★ | ★ | ○ | ☆ | | ● | ● | ○ | ● | ● | | ○ | ● | ● | ○ | ● | | ● | ○ | ○ | ○ | ● | | | | | --- | | | | → | | | | | | | ● | ● | ● | ● | ● | | --- | --- | --- | --- | --- | | ● | ● | ● | ○ | ● | | ● | ○ | ● | ● | ○ | | ○ | ● | ● | ○ | ● | | ● | ○ | ○ | ○ | ● | | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | |
ピーター : つまり、図1の左側★印の光電管を粒子が通過した場合、
右側のように点灯すると言うことですね。
(図は 5 × 5 の例。黒は消灯・白は点灯状態。以下同じ。)
博士 : また反応とは、光電管の状態が反転する。つまり消えている光電管は光り、
光っている光電管は消える。
ピーター : つまり、図2の左側の★印や☆印を粒子が通過した場合、右側のような状態になると。
博士 : これを正方形になんと 100 個 (10 × 10) 配置して待ち受けるわけだ。
ピーター : これだけの大発明、ノーベル賞選考委員会も「ホッチャオカンデ」なんて。
博士 : おぉピーター君、君も我が研究室の作風になじんできたようだね。いい感じだ。
では、早速実験を始めよう。まずはこの装置、現在ランダムに光電管が点いているので、
実験が始められるように全部消えた状態にリセットしてくれたまえ。
なあに、どの光電管にアキシオン粒子を当てれば全部消えるか考えればいいだけじゃよ。
簡単だろう?
ピーター : 考えるのはいいんですが博士。当てるためには、
幻のアキシオン粒子を発生させて打ち込める装置がないといけないんじゃないですか。
博士 : ・・・。
博士とピータ (同時に)コリャアカンデ!だははは・・・・。
ー:
ということで、本日も和気あいあいと暮れてゆく博士の研究室ですが、例によって話は全く進みそうもありません。しょうがないので、ピーター君に代わってプログラムを作成してあげてください。
プログラムは次のようなものになります。
A. 装置の光電管の状態を 10 × 10 の配列として入力します。0は消灯中、1は点灯中を表します。
0 と 1 以外のデータは含まれません。
B. 入力した装置の状態をすべて消灯にするために、アキシオン粒子を通過させる位置を計算して出力します。これは、入力と同じ 10 × 10の配列で光電管の位置を表します。「0 は通過させない」、「1 は通過させる」ことを表します。すべてを消灯する方法は必ず 1 通りだけ存在するものとします。
Input
-----
複数のデータセットが与えられます。１行目にデータセットの数 n (n ≤ 20) が与えられます。各データセットは以下の形式で与えられます。
```
a1,1 a1,2 ... a1,10
a2,1 a2,2 ... a2,10
:
a10,1 a10,2 ... a10,10
```
ai,j は装置の i 行目 j 列目の光電管の状態を示す整数 (0 または 1) を表します。
Output
------
各データセットについて、粒子を通過させる位置を以下の形式で出力してください。
```
b1,1 b1,2 ... b1,10
b2,1 b2,2 ... b2,10
:
b10,1 b10,2 ... b10,10
```
bi,j は装置の i 行目 j 列目の光電管に粒子を通過させるかいなかを示す整数 (0 または 1) を表します。
Sample Input
------------
```
1
0 1 0 0 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 1 0 0 1 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 0 0 1 0
```
Output for the Sample Input
---------------------------
```
0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0
```
| #include<iostream>
using namespace std;
int t[10][10],u[10][10],ans[10][10],n,flg;
int compute();
void dfs(int);
void change(int,int);
int main(){
cin>>n;
while(n--){
flg=0;
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
cin>>t[i][j];
ans[i][j]=0;
}
}
dfs(0);
}
return 0;
}
void dfs(int x){
if(x==10){
/*
for(int i=0;i<10;i++)cout<<ans[0][i];
cout<<endl;
*/
if(compute()){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(j)cout<<' ';
cout<<ans[i][j];
}
cout<<endl;
}
}
return;
}
ans[0][x]=0;
dfs(x+1);
ans[0][x]=1;
dfs(x+1);
}
int compute(){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
u[i][j]=t[i][j];
if(i)ans[i][j]=0;
}
}
for(int i=0;i<10;i++){
if(ans[0][i])change(0,i);
}
for(int i=1;i<10;i++){
for(int j=0;j<10;j++){
if(u[i-1][j]){
ans[i][j]=1;
change(i,j);
}
}
}
for(int i=0;i<10;i++){
if(u[9][i])return 0;
}
return 1;
}
void change(int y,int x){
u[y][x]=!u[y][x];
if(y>0)u[y-1][x]=!u[y-1][x];
if(x>0)u[y][x-1]=!u[y][x-1];
if(y<9)u[y+1][x]=!u[y+1][x];
if(x<9)u[y][x+1]=!u[y][x+1];
} | #include<iostream>
using namespace std;
int I,flg;
int t[10][10],u[10][10];
int ans[10][10];
void check();
void dfs(int);
void compute(int,int);
int main(){
cin>>I;
while(I--){
flg=0;
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
cin>>t[i][j];
u[i][j]=t[i][j];
ans[i][j]=0;
}
}
dfs(0);
}
return 0;
}
void dfs(int x){
if(flg)return;
if(x==10){
check();
}else{
ans[0][x]=0;
dfs(x+1);
if(flg)return;
ans[0][x]=1;
dfs(x+1);
}
}
void check(){
if(flg)return;
for(int i=0;i<10;i++)for(int j=0;j<10;j++)t[i][j]=u[i][j];
for(int i=0;i<10;i++)if(ans[0][i]==1)compute(0,i);
for(int i=1;i<10;i++){
for(int j=0;j<10;j++){
ans[i][j]=0;
if(t[i-1][j]==1){
ans[i][j]=1;
compute(i,j);
}
}
}
/*
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(j)cout<<' ';
cout<<t[i][j];
}
cout<<endl;
}
*/
int cnt=0;
for(int i=0;i<10;i++)cnt+=t[9][i];
if(cnt==0){
flg=1;
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(j)cout<<' ';
cout<<ans[i][j];
}
cout<<endl;
}
}
}
void compute(int y,int x){
t[y][x]=(t[y][x]*-1)+1;
if(y>0)t[y-1][x]=(t[y-1][x]*-1)+1;
if(x>0)t[y][x-1]=(t[y][x-1]*-1)+1;
if(y<9)t[y+1][x]=(t[y+1][x]*-1)+1;
if(x<9)t[y][x+1]=(t[y][x+1]*-1)+1;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
素数の性質
=====
4 で割ると 3 あまる素数 n (11、19、23 など) には、面白い性質があります。1 以上 n 未満の自然数 (1, 2,... , n - 1) を 2 乗したものを n で割ったあまりを計算した結果を並べると、同じ数になるものがあるため、互いに異なった数の個数は、(n - 1)/2 になります。
この様にして得られた数の集合には、特別な性質があります。得られた数の集合から、互いに異なる 2 つ a と b を選んでその差を計算します。差が負になったときは、その差に n を足します。さらに結果が (n - 1)/2 より大きいときは、その差を n から引きます。
例えば、n = 11 のとき 1 と 9 の差は、1 − 9 = −8 → −8 + n = −8 + 11 = 3 になります。9 と 1 の差も 9 −1 = 8 → n − 8 = 11 − 8 = 3 で、同じ値 3 になります。この差は、円周上に 0, 1, ・・・, n - 1 を書いて、二つの数字の間の短い方の円弧を考えるとわかりやすくなります。(下図参照)
こうして得られた数の「差」は、1, 2, . . ., (n - 1)/2 のいずれかであり、同じ回数出現します。
【例】 n = 11 の時は、以下のようになります。
1. 1 から n-1 までの数を 2 乗したものを n で割った余りを計算します。
```
12 = 1 → 1
22 = 4 → 4
32 = 9 → 9
42 = 16 → 5
52 = 25 → 3
62 = 36 → 3
72 = 49 → 5
82 = 64 → 9
92 = 81 → 4
102 = 100 → 1
```
2. a, b の「差」の計算
1. 1 で得られた 1, 3, 4, 5, 9 について異なる数同士の差を計算します。
2. 計算結果が負の場合、n = 11 を加算します。
3. さらに、計算結果が (n-1)/2 = 5 より大きい場合 n = 11 から減算します。
3. 出現回数を求める
計算結果 1, 2, 3, 4, 5 の出現回数をそれぞれ数え上げます。
これらの計算結果から 1, 2, 3, 4, 5 の出現回数が 4 回であることがわかります。この性質は 4 で割ると 3 あまる素数特有の性質であり 4 で割ると 1 あまる素数ではこのようなことはおきません。このことを確認するため、10000 以下の奇数 n を入力とし、例題にあるような計算 (n で割ったあまりの 2 乗の差の頻度を求める)を実行し、その出現回数を出力するプログラムを作成してください。
Input
-----
複数のデータセットが与えられます。各データセットとして１つの整数 n (n ≤ 10000) が１行に与えられます。入力は 0 を１つ含む行でおわります。
Output
------
各データセットについて、出現頻度を以下の形式で出力してください。
```
剰余の平方の差が 1 である(a, b)の出現個数(整数)
剰余の平方の差が 2 である(a, b)の出現個数(整数)
:
:
剰余の平方の差が (n-1)/2 である(a, b)の出現個数(整数)
```
Sample Input
------------
```
11
15
0
```
Output for the Sample Input
---------------------------
```
4
4
4
4
4
2
2
4
2
4
4
2
```
| #include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <cstring>
#include <deque>
#include <cstdio>
#include <cmath>
using namespace std;
#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)
#define rep(i,n) reep(i, 0, n)
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int main()
{
int n;
while(scanf("%d", &n), n){
vi nums(n, 0);
reep(i, 1, n)
nums[(i*i)%n] |= 1;
reep(i, 1, (n+1)/2){
int sum = 0;
rep(j, n)
sum += nums[j] & nums[(j+i)%n];
printf("%d\n", sum * 2);
}
}
return 0;
} | #include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <cstring>
#include <deque>
#include <cstdio>
#include <cmath>
using namespace std;
#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)
#define rep(i,n) reep(i, 0, n)
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int main()
{
int nums[16384], ans[8192];
int i, j, n, size, half;
while(scanf("%d", &n), n){
size = 0;
half = (n-1) / 2;
for(i=1; i<n; ++i)
nums[size++] = (i*i) % n;
sort(nums, nums + size);
size = unique(nums, nums + size) - nums;
memset(ans, 0, (half+1)*4);
for(i=0; i<size; ++i){
for(j=0; j<i; ++j){
int p = abs(nums[i]-nums[j]);
if(p>half) p = n - p;
++ans[p];
}
}
for(i=1; i<=half; ++i)
printf("%d\n", ans[i]*2);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
牽牛と織女
=====
織女は天帝の子供でしたが、父の言いつけであけてもくれても機を織っていました。
織女の織る雲錦という見事な布で仕立てた服を着るのが天帝の楽しみでした。雲錦は寿命が短くすぐに劣化してしまいますが、働き者の織女が毎日織ってくれるので、問題はありませんでした。織女は、父の言いつけを守り、毎日毎日雲錦を織り続けていたので、ボーイフレンドはいませんでした。かわいそうに思った父は、天の川の向こう岸に住む牽牛という働き者を紹介し、嫁入りさせました。
すると、織女は、結婚の楽しさに夢中になって、機織りなどそっちのけで、牽牛と遊び呆けています。天帝のお気に入りの雲錦の服も新しく仕立てられないためボロボロになってしまいました。
これには父も怒って、織女を宮殿に連れ戻したいと思いました。しかし人間である牽牛の前にボロボロの服で姿を現すわけにはいきません。遊び呆けている二人を 3 角形の壁で遮断し自分以外の全てのものが行き来できなくすることを考えました。そして、牽牛に見つからずに、織女に会って、まじめに機を織るか、さもなければ強制的に連れ帰ると宣言するというのです。
天帝はこの作戦を遂行するために 3 角形の壁生成装置を開発することにしました。3 角形の 3 頂点の位置 (xp1, yp1), (xp2, yp2), (xp3, yp3)、牽牛の位置 (xk, yk)、および織女の位置 (xs, ys)、を入力とし、三角形が牽牛と織女を遮断しているか否かを判定し、遮断できている場合は OK、遮断できていない場合には NG を出力するプログラムを作成してください。ただし、遮断しているとは、牽牛と織女のいずれかが三角形の内側にあり、他方が外側にある場合を言います。牽牛と織女は三角形の頂点もしくは辺の上にはいないものとします。
織女と牽牛は時々刻々場所を変えるため、プログラムは様々な位置情報を入力し質問に答えなければなりません。
Input
-----
入力は以下の形式で与えられます。
```
n
query1
query2
:
queryn
```
１行目に判別したい情報の個数 n (n ≤ 10000)、続く n 行に i 番目の質問 queryi が与えられます。各質問は以下の形式で与えられます。
```
xp1 yp1 xp2 yp2 xp3 yp3 xk yk xs ys
```
各質問として、3 角形の 3 頂点の位置、牽牛の位置、および織女の位置 (-1000 ≤ xp1, yp1, xp2, yp2, xp3, yp3, xk, yk, xs, ys ≤ 1000) が１行に与えられます。入力はすべて整数です。
Output
------
質問ごとに、判定結果 OK または NG を１行に出力してください。
Sample Input
------------
```
5
2 5 9 2 8 9 2 11 6 5
2 5 9 2 8 9 2 11 12 6
2 5 9 2 8 9 2 11 11 9
14 1 25 7 17 12 17 9 20 5
14 1 25 7 17 12 22 13 20 5
```
Output for the Sample Input
---------------------------
```
OK
NG
NG
NG
OK
```
| /**************** Geometrical Library ****************/
#include<cmath>
#include<vector>
#include<algorithm>
#define EPS 1e-9
enum {CCW=1,CW=-1,ON=0};
#define mp make_pair
#define pb push_back
using namespace std;
class Point{
public:
double x,y;
Point(){}
Point(double xx,double yy):x(xx),y(yy){}
};
class Line:public vector<Point>{
public:
Line(const Point &a,const Point &b){
pb(a),pb(b);
}
};
class Segment:public Line{
public:
Segment(const Point &a,const Point &b):Line(a,b){}
};
class Polygon:public vector<Point>{};
class Circle{
public:
Point c;
double r;
Circle(const Point &cc,double rr) : c(cc),r(rr){}
};
Point &operator +=(Point &a,const Point &b){
a.x+=b.x,a.y+=b.y;
return a;
}
Point &operator -=(Point &a,const Point &b){
a.x-=b.x,a.y-=b.y;
return a;
}
Point &operator *=(Point &a,double c){
a.x*=c,a.y*=c;
return a;
}
Point &operator /=(Point &a,double c){
a.x/=c,a.y/=c;
return a;
}
Point operator +(const Point &a,const Point &b){
Point c=a;
return c+=b;
}
Point operator -(const Point &a,const Point &b){
Point c=a;
return c-=b;
}
Point operator *(double c,const Point &a){
Point b=a;
return b*=c;
}
Point operator /(const Point &a,double c){
Point b=a;
return b/=c;
}
bool operator <(const Point &a,const Point &b){
return (a.x==b.x)?(a.y<b.y):(a.x<b.x);
}
bool operator >(const Point &a,const Point &b){
return b<a;
}
double dot(const Point &a,const Point &b){
return a.x*b.x+a.y*b.y;
}
double cross(const Point &a,const Point &b){
return a.x*b.y-a.y*b.x;
}
double dis2(const Point &a,const Point &b){
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
int ccw(const Point &a,Point b,Point c){
b-=a,c-=a;
double rotdir=cross(b,c);
if(rotdir>EPS) return CCW;
if(rotdir<-EPS) return CW;
return ON;
}
Polygon ConvexHull(vector<Point> ps){
int n=ps.size();
sort(ps.begin(),ps.end());
vector<Point> ch_u(n);
int n_u=0;
for(int i=n-1;i>=0;i--){
ch_u[n_u++]=ps[i];
while(n_u>=3 && ccw(ch_u[n_u-3],ch_u[n_u-2],ch_u[n_u-1])!=CCW){
ch_u[n_u-2]=ch_u[n_u-1];
n_u--;
}
}
vector<Point> ch_l(n);
int n_l=0;
for(int i=0;i<n;i++){
ch_l[n_l++]=ps[i];
while(n_l>=3 && ccw(ch_l[n_l-3],ch_l[n_l-2],ch_l[n_l-1])!=CCW){
ch_l[n_l-2]=ch_l[n_l-1];
n_l--;
}
}
Polygon ch;
for(int i=0;i<n_u-1;i++) ch.pb(ch_u[i]);
for(int i=0;i<n_l-1;i++) ch.pb(ch_l[i]);
return ch;
}
/*
bool parallel(const Line &l,const Line &m){
return abs(cross(l[1]-l[0],m[1]-m[0]))<EPS;
}
bool orthogonal(const Line &l,const Line &m){
return abs(dot(l[1]-l[0],m[1]-m[0]))<EPS;
}
*/
inline void calc_abc(const Line &l,double &a,double &b,double &c){ // l : ax+by+c=0
a=l[0].y-l[1].y;
b=l[1].x-l[0].x;
c=l[0].x*l[1].y-l[1].x*l[0].y;
}
bool intersect(const Line &l,const Line &m,Point *p=NULL){
// this routine also returns true in case "M is on L", "M sessuru L", etc,.
if(abs(cross(l[1]-l[0],m[1]-m[0]))>EPS
|| abs(cross(l[1]-l[0],m[0]-l[0]))<EPS){
if(p){
double a1,b1,c1,a2,b2,c2;
calc_abc(l,a1,b1,c1);
calc_abc(m,a2,b2,c2);
double det=a1*b2-a2*b1;
if(abs(det)<EPS) *p=l[0]; // l == m
else{
p->x=(b1*c2-b2*c1)/det;
p->y=(a2*c1-a1*c2)/det;
}
}
return true;
}
return false;
}
bool intersect(const Segment &s,const Segment &t,Point *p=NULL){
if(max(s[0].x,s[1].x)<min(t[0].x,t[1].x)
|| max(t[0].x,t[1].x)<min(s[0].x,s[1].x)
|| max(s[0].y,s[1].y)<min(t[0].y,t[1].y)
|| max(t[0].y,t[1].y)<min(s[0].y,s[1].y)) return false;
if(ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1])<=0
&& ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1])<=0){
if(p){
double a1,b1,c1,a2,b2,c2;
calc_abc(s,a1,b1,c1);
calc_abc(t,a2,b2,c2);
double det=a1*b2-a2*b1;
if(abs(det)<EPS){ // s is parallel to t
Point q[3]={s[0],s[1],t[0]};
for(int i=0;i<3;i++){
if(dot(q[i]-s[0],q[i]-s[1])<EPS && dot(q[i]-t[0],q[i]-t[1])<EPS){
*p=q[i];
break;
}
}
}
else{
p->x=(b1*c2-b2*c1)/det;
p->y=(a2*c1-a1*c2)/det;
}
}
return true;
}
return false;
}
Point perp_foot(const Point &p,const Line &l){
double a,b,c;
calc_abc(l,a,b,c);
return p-(a*p.x+b*p.y+c)/(a*a+b*b)*Point(a,b);
}
Line perp_bisector(const Point &a,const Point &b){
return Line(Point((a.x+a.y+b.x-b.y)/2,(b.x+b.y-a.x+a.y)/2),
Point((b.x+b.y+a.x-a.y)/2,(a.x+a.y-b.x+b.y)/2));
}
/*
double area(const Point &a,const Point &b,const Point &c){
return abs(cross(b-a,c-a))/2;
}
*/
double area(const Polygon &pl){
int n=pl.size();
double a=0;
for(int i=0;i<n;i++) a+=cross(pl[i],pl[(i+1)%n]);
return abs(a)/2;
}
/**************** Library END ****************/
#include<cstdio>
int main(){
int n; scanf("%d",&n);
while(n--){
Point a,b,c,star[2];
scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf",
&a.x,&a.y,&b.x,&b.y,&c.x,&c.y,&star[0].x,&star[0].y,&star[1].x,&star[1].y);
bool in[2];
for(int i=0;i<2;i++){
int cnt=0;
cnt+=ccw(a,b,star[i]);
cnt+=ccw(b,c,star[i]);
cnt+=ccw(c,a,star[i]);
in[i]=(cnt==3*CCW || cnt==3*CW);
}
puts(in[0]==in[1]?"NG":"OK");
}
return 0;
} | /**************** Geometrical Library ****************/
#include<cmath>
#include<vector>
#include<algorithm>
#define EPS 1e-9
enum {CCW=1,CW=-1,ON=0};
#define mp make_pair
#define pb push_back
using namespace std;
class Point{
public:
double x,y;
Point(){}
Point(double xx,double yy):x(xx),y(yy){}
};
class Line:public vector<Point>{
public:
Line(const Point &a,const Point &b){
pb(a),pb(b);
}
};
class Segment:public Line{
public:
Segment(const Point &a,const Point &b):Line(a,b){}
};
class Polygon:public vector<Point>{};
class Circle{
public:
Point c;
double r;
Circle(const Point &cc,double rr) : c(cc),r(rr){}
};
Point &operator +=(Point &a,const Point &b){
a.x+=b.x,a.y+=b.y;
return a;
}
Point &operator -=(Point &a,const Point &b){
a.x-=b.x,a.y-=b.y;
return a;
}
Point &operator *=(Point &a,double c){
a.x*=c,a.y*=c;
return a;
}
Point &operator /=(Point &a,double c){
a.x/=c,a.y/=c;
return a;
}
Point operator +(const Point &a,const Point &b){
Point c=a;
return c+=b;
}
Point operator -(const Point &a,const Point &b){
Point c=a;
return c-=b;
}
Point operator *(double c,const Point &a){
Point b=a;
return b*=c;
}
Point operator /(const Point &a,double c){
Point b=a;
return b/=c;
}
bool operator <(const Point &a,const Point &b){
return (a.x==b.x)?(a.y<b.y):(a.x<b.x);
}
bool operator >(const Point &a,const Point &b){
return b<a;
}
double cross(const Point &a,const Point &b){
return a.x*b.y-a.y*b.x;
}
int ccw(const Point &a,Point b,Point c){
b-=a,c-=a;
double rotdir=cross(b,c);
if(rotdir>EPS) return CCW;
if(rotdir<-EPS) return CW;
return ON;
}
/**************** Library END ****************/
#include<cstdio>
int main(){
int n; scanf("%d",&n);
while(n--){
Point a,b,c,star[2];
scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf",
&a.x,&a.y,&b.x,&b.y,&c.x,&c.y,&star[0].x,&star[0].y,&star[1].x,&star[1].y);
bool in[2];
for(int i=0;i<2;i++){
int cnt=0;
cnt+=ccw(a,b,star[i]);
cnt+=ccw(b,c,star[i]);
cnt+=ccw(c,a,star[i]);
in[i]=(cnt==3*CCW || cnt==3*CW);
}
puts(in[0]==in[1]?"NG":"OK");
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Twin Prime
==========
Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.
In this problem, we call the greater number of a twin prime "size of the twin prime."
Your task is to create a program which reads an integer *n* and prints a twin prime which has the maximum size among twin primes less than or equals to *n*
You may assume that 5 ≤ *n* ≤ 10000.
Input
-----
The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:
```
n (integer)
```
Output
------
For each dataset, print the twin prime *p* and *q* (*p* < *q*). *p* and *q* should be separated by a single space.
Sample Input
------------
```
12
100
200
300
0
```
Output for the Sample Input
---------------------------
```
5 7
71 73
197 199
281 283
```
| #include<stdio.h>
const int MAX_X = 10000;
int prime[10000];
int main(){
int i, k, n;
int border[10];
for( i = 2; i <= MAX_X; i++) {
prime[i] = 1;
}
for(i = 2; i*i <= MAX_X; i++){
if(prime[i]) {
for(k = 2 * i; k <= MAX_X; k += i){
prime[k] = 0;
}
}
}
while(1){
scanf("%d", &n);
if( n == 0) break;
int max;
for( i = n; i >= 2; i--){
if( prime[i]){
if( prime[i - 2]){
max = i;
break;
}
}
}
printf("%d %d\n", max -2, max);
}
return 0;
} | #include<stdio.h>
int isprime(int n){
for(int i = 2; i * i <= n; i++){
if( n % i == 0) return 0;
}
return 1;
}
int main(){
int n, i;
while(1){
scanf("%d", &n);
if( n == 0) break;
int max = 0;
for( i = n; i >=2; i--){
if( isprime(i)){
if(isprime( i - 2)){
max = i;
break;
}
}
}
printf("%d %d\n", max - 2, max);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Twin Prime
==========
Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.
In this problem, we call the greater number of a twin prime "size of the twin prime."
Your task is to create a program which reads an integer *n* and prints a twin prime which has the maximum size among twin primes less than or equals to *n*
You may assume that 5 ≤ *n* ≤ 10000.
Input
-----
The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:
```
n (integer)
```
Output
------
For each dataset, print the twin prime *p* and *q* (*p* < *q*). *p* and *q* should be separated by a single space.
Sample Input
------------
```
12
100
200
300
0
```
Output for the Sample Input
---------------------------
```
5 7
71 73
197 199
281 283
```
| #include "stdio.h"
const int MAX_V = 10000; // 1????????§????´???°??¨?????????
int prime[MAX_V+1]; // 1????´???°,0????´???°??§?????????
int main() {
int i, k, n;
for(i = 2; i <= MAX_V; i++){
prime[i] = 1; // 2??\???????´???°??¨??????
}
for(i = 2; i * i <= MAX_V; i++) {
if(prime[i]) {
for(k = 2 * i; k <= MAX_V; k += i) {
prime[k] = 0; // ?´???°???2?????\???????????°????´???°??§?????????
}
}
}
while (1) {
scanf("%d",&n);
if (n == 0)break;
// while(scanf("%d", &n) != 0) {
int p1 = 0,q1 = 0;
for(i = n;3 <= i;i--){
if(prime[i] == 1 && prime[i-2] == 1){ //??????????´???°
q1 = i;
p1 = i-2;
break;
}
}
printf("%d %d\n",p1,q1);//for?????????????????????
}
return 0;
}
//????¨??????¨???????????????????????? | #include "stdio.h"
//#include "time.h"
//?????§??????????´???°?????????????????????
// 5<= n <= 10000
//p1=?°????????´???°p2=??§???????´???°
int isprime(int n) {
int i;
for(i = 2; i * i <= n; i++) { //??????????§????????????¨??§??¶??°??§??????????´???°??¨??????
if(n % i == 0)return 0; //????????????????????§?´???°??§?????????
}
return 1;
}
int main(){
int i,n,p1,q1;
// clock_t start, now;//??£?¨?
while(1){
scanf("%d",&n);
// start = clock(); // ????§???????
if(n == 0)break;
for(i = n;3 <= i;i--){
if (isprime(i) == 1 && isprime(i - 2) == 1) break;
}
p1 = i-2;
q1 = i;
// now = clock(); // ????????????
// printf("%f\n", (double)(now - start) / CLOCKS_PER_SEC);//??¬???
printf("%d %d\n",p1,q1);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Twin Prime
==========
Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.
In this problem, we call the greater number of a twin prime "size of the twin prime."
Your task is to create a program which reads an integer *n* and prints a twin prime which has the maximum size among twin primes less than or equals to *n*
You may assume that 5 ≤ *n* ≤ 10000.
Input
-----
The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:
```
n (integer)
```
Output
------
For each dataset, print the twin prime *p* and *q* (*p* < *q*). *p* and *q* should be separated by a single space.
Sample Input
------------
```
12
100
200
300
0
```
Output for the Sample Input
---------------------------
```
5 7
71 73
197 199
281 283
```
| #include <stdio.h>
int main() {
int i, k, v,an1,an2,suu;
int MAX_V = 10000;
int prime[MAX_V+1];
for(i = 0; i <= MAX_V; i++) {
prime[i] = 1;
}
for(i = 2; i*i <= MAX_V; i++) {
if(prime[i]) {
for(k = 2 * i; k <= MAX_V; k += i) {
prime[k] = 0;
}
}
}
while(1){
scanf("%d",&suu);
if(suu != 0){
for(k=2;k<=suu;k++){
if(prime[k-2]==1 && prime[k]==1){
an1=k-2;
an2=k;
}
}
printf("%d %d\n",an1,an2);
}
else{
break;
}
}
return 0;
} | #include <stdio.h>
int isprime(int n) {
int i;
for(int i = 2; i * i <= n; i++) {
if(n % i == 0) return 0;
}
return 1;
}
int main(){
int k,suu,an1,an2;
while(1){
scanf("%d",&suu);
if(suu == 0) break;
for(k=suu;k>0;k--){
if(isprime(k-2)==1 && isprime(k)==1){
an1=k-2;
an2=k;
break;
}
}
printf("%d %d\n",an1,an2);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Twin Prime
==========
Prime numbers are widely applied for cryptographic and communication technology.
A twin prime is a prime number that differs from another prime number by 2.
For example, (5, 7) and (11, 13) are twin prime pairs.
In this problem, we call the greater number of a twin prime "size of the twin prime."
Your task is to create a program which reads an integer *n* and prints a twin prime which has the maximum size among twin primes less than or equals to *n*
You may assume that 5 ≤ *n* ≤ 10000.
Input
-----
The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset is formatted as follows:
```
n (integer)
```
Output
------
For each dataset, print the twin prime *p* and *q* (*p* < *q*). *p* and *q* should be separated by a single space.
Sample Input
------------
```
12
100
200
300
0
```
Output for the Sample Input
---------------------------
```
5 7
71 73
197 199
281 283
```
| #include <stdio.h>
const int MAX_V = 10000; // 1????????§????´???°??¨?????????
int main() {
int i, k, n, p, q;
int prime[MAX_V+1]; // 1????´???°???0????´???°??§?????????
for(i = 2; i <= MAX_V; i++) {
prime[i] = 1; // 2??\???????´???°??¨??????
}
for(i = 2; i*i <= MAX_V; i++) {
if(prime[i]) {
for(k = 2 * i; k <= MAX_V; k += i) {
prime[k] = 0; // ?´???°???2?????\???????????°????´???°??§?????????
}
}
}
//?´???°??¨fin
//while(scanf("%d",&n) != 0){
while(1){
scanf("%d",&n);
if(n==0)break;
for(i=n;i>=3;i--){//???????????¨????´???°????????????
if(prime[i] == 1 && prime[i-2] == 1){
p = i;
q = p-2;
break;
}
}
// ans[a]=i; a++;
// ans[a]=i-2; a++;
// }
// for(i=0;i<=a;i=i+2){
// printf("%d %d\n",ans[i],ans[i+1]);
// }
printf("%d %d\n",q,p);
}
return 0;
} | #include <stdio.h>
#include <time.h>
int isprime(int n){
for(int i = 2; i * i <= n; i++){
if(n % i == 0){
return 0;
}
}
return 1;
}
int main() {
int i,p,q,n;
while(1){
scanf("%d",&n);
if(n == 0){
break;
}
for(i=n;i>=2;i--){
if(isprime(i) && isprime(i-2) ){
break;
}
}
printf("%d %d\n",i-2,i);
}
return 0;
}
// clock_t start, now;
// now = clock();
// printf("%f\n",(double)(now - start) / CLOCKS_PER_SEC); | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
城の堀
===
いま、忍者が城外から天守閣に忍び入ろうと計画を立てています。この忍者は地面を走ったり、堀の中を泳いだりすることは難なくできますが、堀から這い上がることはとても苦手なので、忍者は堀に入る回数をできるだけ少なくしたいと考えています。
お城の見取図を入力とし、城外から天守閣に至るまでに、堀から這い上がらなくてはならない最小回数を出力するプログラムを作成して下さい。お城の見取図は二次元格子として与えられます。見取り図に描かれた記号には、天守閣の位置を示す「&」と堀の位置を示す「#」の位置が記され、そのほかの地点には「.」（半角ピリオド）が記されています。なお、お城には天守閣は一つだけあるものとし、忍者は走ったり泳いだりして移動するときに東西南北方向に1マスずつ移動するものとし、斜めには移動しません。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロ２つの行で示されます。各データセットは以下の形式で与えられます。
```
n m
c1,1c1,2...c1,n
c2,1c2,2...c2,n
:
cm,1cm,2...cm,n
```
１行目に見取図の東西の幅 n と 南北の幅 m (1 ≤ n, m ≤ 100) が与えられる。続くm 行に見取り図の i 行目の情報が与えられる。各情報は記号「&」、「#」、「.」からなる長さ n の文字列である。
データセットの数は 50 を越えない。
Output
------
データセットごとに堀から這い上がらなくてはならない最小回数（整数）を１行に出力します。
Sample Input
------------
```
5 5
.###.
#...#
#.&.#
#...#
.###.
18 15
..####....####....
####..####....####
#...............##
.#.############.##
#..#..........#.##
.#.#.########.#.##
#..#.#......#.#.##
.#.#....&...#.#.##
#..#........#.#.##
.#.#.########.#.##
#..#..........#.##
.#.############.##
#...............##
.#################
##################
9 10
#########
........#
#######.#
#.....#.#
#.###.#.#
#.#&#.#.#
#.#...#.#
#.#####.#
#.......#
#########
9 3
###...###
#.#.&.#.#
###...###
0 0
</pre>
<H2>Output for the Sample Input</H2>
<pre>
1
2
0
0
</pre>
```
| #include<iostream>
#include<vector>
#include<string>
#include<stack>
using namespace std;
int main(){
int w,h;
string line;
while(true){
cin>>w>>h;
if(!w&&!h)
break;
vector<string> castle;
for(int i=0;i<h;i++){
cin>>line;
castle.push_back(line);
}
int count[w+2][h+2];
int sx,sy;
const int MAX = 1000;
for(int y=1;y<h+1;y++){
for(int x=1;x<w+1;x++){
count[x][y] = MAX;
if (castle[y-1][x-1]=='&'){
sx = x;
sy = y;
castle[y-1][x-1]='.';
}
}
}
int min = MAX;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
count[sx][sy] = 0;
stack<int> st;
st.push(sy*(w+2)+sx);
while(!st.empty()){
int x = st.top()%(w+2);
int y = st.top()/(w+2);
st.pop();
char c = castle[y-1][x-1];
int n;
for(int d=0;d<4;d++){
n = count[x][y];
if(x+dx[d]>0&&y+dy[d]>0&&x+dx[d]<w+1&&y+dy[d]<h+1){
if(c=='.'&&castle[y+dy[d]-1][x+dx[d]-1]=='#')
n++;
if(n<count[x+dx[d]][y+dy[d]]){
count[x+dx[d]][y+dy[d]] = n;
st.push((y+dy[d])*(w+2)+x+dx[d]);
}
}
else{
if(n<min)
min = n;
}
}
}
cout<<min<<endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<queue>
using namespace std;
int main(){
int w,h;
string line;
while(true){
cin>>w>>h;
if(!w&&!h)
break;
vector<string> castle;
for(int i=0;i<h;i++){
cin>>line;
castle.push_back(line);
}
int count[w+2][h+2];
int sx,sy;
const int MAX = 100;
for(int y=1;y<h+1;y++){
for(int x=1;x<w+1;x++){
count[x][y] = MAX;
if (castle[y-1][x-1]=='&'){
sx = x;
sy = y;
castle[y-1][x-1]='.';
}
}
}
int min = MAX;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
count[sx][sy] = 0;
queue<int> st;
st.push(sy*(w+2)+sx);
while(!st.empty()){
int x = st.front()%(w+2);
int y = st.front()/(w+2);
st.pop();
char c = castle[y-1][x-1];
int n;
for(int d=0;d<4;d++){
n = count[x][y];
if(x+dx[d]>0&&y+dy[d]>0&&x+dx[d]<w+1&&y+dy[d]<h+1){
if(c=='.'&&castle[y+dy[d]-1][x+dx[d]-1]=='#')
n++;
if(n<count[x+dx[d]][y+dy[d]]){
count[x+dx[d]][y+dy[d]] = n;
st.push((y+dy[d])*(w+2)+x+dx[d]);
}
}
else{
if(n<min)
min = n;
}
}
}
cout<<min<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
マトリョーシカ
=======
マトリョーシカとは女性像をかたどった木製の人形で、ロシアの代表的な民芸品です。マトリョーシカは、大きな人形の中にそれより小さな人形が入っている入れ子構造になっており、大きさの異なる複数の人形で構成されています。このような入れ子構造にするため、各人形の胴体は上下で分割できる筒状の構造になっています。マトリョーシカは職人の手で手作りされるため、一つ一つの人形は世界に一つしかない非常に貴重なものになります。
兄弟である一郎君と次郎君は、マトリョーシカで遊ぶのが大好きで、各自がそれぞれ1組のマトリョーシカを持っていました。一郎君のマトリョーシカは n 個の人形から構成されており、次郎君のマトリョーシカは m 個の人形から構成されています。
ある日、好奇心が旺盛な一郎君は、これら2組のマトリョーシカに含まれる人形たちを組み合わせて、より多くの人形を含む新たなマトリョーシカを作れないかと考えました。つまり、n + m 個の人形を使い、k 個の人形からなる１組のマトリョーシカを作ることを試みたのです。n と m の大きい方よりも k を大きくすることができれば、一郎君の目的は達成されます。
兄弟は2人仲良く、どのように人形を組み合わせれば k の値を最大にできるかを考えました。しかし、幼い2人にとってこの問題はあまりにも難しいので、年上のあなたはプログラムを作成して弟たちを助けることにしました。
一郎君と次郎君のマトリョーシカの人形の情報を入力とし、新たなマトリョーシカが含む人形の数 k を出力するプログラムを作成して下さい。入力される人形に大きさが同じものは存在しません。また、人形を高さ h 半径 r の円柱とみなした場合、高さh、半径 r の人形が含むことのできる人形は x < h かつ y < r を満たす高さ x 半径 y の人形です。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。
```
n
h1 r1
h2 r2
:
hn rn
m
h1 r1
h2 r2
:
hm rm
```
１行目に一郎君のマトリョーシカの人形の数 n (n ≤ 100)、続く n 行に一郎君の第 i の人形の高さ hi と半径 ri (hi, ri < 1000) が与えられます。
続く行に二郎君のマトリョーシカの人形の数 m (m ≤ 100)、続く m 行に二郎君の第 i の人形の高さ hi と半径 ri (hi, ri < 1000) が与えられます。
データセットの数は 20 を越えない。
Output
------
入力データセットごとに新たなマトリョーシカが含む人形の数 k を出力します。
Sample Input
------------
```
6
1 1
4 3
6 5
8 6
10 10
14 14
5
2 2
5 4
6 6
9 8
15 10
4
1 1
4 3
6 5
8 6
3
2 2
5 4
6 6
4
1 1
4 3
6 5
8 6
4
10 10
12 11
18 15
24 20
0
```
Output for the Sample Input
---------------------------
```
9
6
8
```
| #include<stdio.h>
#include<map>
#include<algorithm>
using namespace std;
typedef pair<int,int> P;
P mt[200];
int dp[1000][201];//hでn個のときのrの最小値
int min(int a,int b){return a<b?a:b;}
int max(int a,int b){return a>b?a:b;}
int main(){
int n,m;
int i,j,k;
while(1){
scanf("%d",&n);
if(n==0)return 0;
for(i=0;i<n;i++){
int a,b;
scanf("%d %d",&a,&b);
mt[i]=P(a,b);
}
scanf("%d",&m);
for(i=0;i<m;i++){
int a,b;
scanf("%d %d",&a,&b);
mt[n+i]=P(a,b);
}
sort(mt,mt+m+n);
for(i=0;i<1000;i++)for(j=0;j<=m+n;j++)dp[i][j]=1000;
for(i=0;i<m+n;i++){
int h=mt[i].first;
int r=mt[i].second;
dp[h][1]=min(dp[h][1],r);
for(j=0;j<h;j++){
for(k=0;k<m+n;k++){
if(r>dp[j][k])dp[h][k+1]=min(dp[h][k+1],r);
}
}
}
int ans=0;
for(i=0;i<1000;i++)for(j=0;j<=m+n;j++){
if(dp[i][j]!=1000)ans=max(ans,j);
}
printf("%d\n",ans);
}
} | #include<stdio.h>
int dp[200];//iが一番外の最大値
int h[200];
int r[200];
int m,n;
int max(int a,int b){return a>b?a:b;}
int dfs(int x){
if(dp[x]!=-1)return dp[x];
int i;
int ans=1;
for(i=0;i<m+n;i++){
if(h[i]<h[x]&&r[i]<r[x])ans=max(ans,dfs(i)+1);
}
return dp[x]=ans;
}
int main(){
while(1){
scanf("%d",&m);
if(m==0)return 0;
int i;
for(i=0;i<m;i++)scanf("%d %d",&h[i],&r[i]);
scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d %d",&h[i+m],&r[i+m]);
int ans=1;
for(i=0;i<m+n;i++)dp[i]=-1;
for(i=0;i<m+n;i++)ans=max(ans,dfs(i));
printf("%d\n",ans);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
マトリョーシカ
=======
マトリョーシカとは女性像をかたどった木製の人形で、ロシアの代表的な民芸品です。マトリョーシカは、大きな人形の中にそれより小さな人形が入っている入れ子構造になっており、大きさの異なる複数の人形で構成されています。このような入れ子構造にするため、各人形の胴体は上下で分割できる筒状の構造になっています。マトリョーシカは職人の手で手作りされるため、一つ一つの人形は世界に一つしかない非常に貴重なものになります。
兄弟である一郎君と次郎君は、マトリョーシカで遊ぶのが大好きで、各自がそれぞれ1組のマトリョーシカを持っていました。一郎君のマトリョーシカは n 個の人形から構成されており、次郎君のマトリョーシカは m 個の人形から構成されています。
ある日、好奇心が旺盛な一郎君は、これら2組のマトリョーシカに含まれる人形たちを組み合わせて、より多くの人形を含む新たなマトリョーシカを作れないかと考えました。つまり、n + m 個の人形を使い、k 個の人形からなる１組のマトリョーシカを作ることを試みたのです。n と m の大きい方よりも k を大きくすることができれば、一郎君の目的は達成されます。
兄弟は2人仲良く、どのように人形を組み合わせれば k の値を最大にできるかを考えました。しかし、幼い2人にとってこの問題はあまりにも難しいので、年上のあなたはプログラムを作成して弟たちを助けることにしました。
一郎君と次郎君のマトリョーシカの人形の情報を入力とし、新たなマトリョーシカが含む人形の数 k を出力するプログラムを作成して下さい。入力される人形に大きさが同じものは存在しません。また、人形を高さ h 半径 r の円柱とみなした場合、高さh、半径 r の人形が含むことのできる人形は x < h かつ y < r を満たす高さ x 半径 y の人形です。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。
```
n
h1 r1
h2 r2
:
hn rn
m
h1 r1
h2 r2
:
hm rm
```
１行目に一郎君のマトリョーシカの人形の数 n (n ≤ 100)、続く n 行に一郎君の第 i の人形の高さ hi と半径 ri (hi, ri < 1000) が与えられます。
続く行に二郎君のマトリョーシカの人形の数 m (m ≤ 100)、続く m 行に二郎君の第 i の人形の高さ hi と半径 ri (hi, ri < 1000) が与えられます。
データセットの数は 20 を越えない。
Output
------
入力データセットごとに新たなマトリョーシカが含む人形の数 k を出力します。
Sample Input
------------
```
6
1 1
4 3
6 5
8 6
10 10
14 14
5
2 2
5 4
6 6
9 8
15 10
4
1 1
4 3
6 5
8 6
3
2 2
5 4
6 6
4
1 1
4 3
6 5
8 6
4
10 10
12 11
18 15
24 20
0
```
Output for the Sample Input
---------------------------
```
9
6
8
```
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
while ( cin >> n, n ) {
vector<int> h(n), r(n);
for (int i = 0; i < n; ++i) {
cin >> h[i] >> r[i];
}
int M; cin >> M;
h.resize(n+M);
r.resize(n+M);
for (int i = 0; i < M; ++i) {
cin >> h[n+i] >> r[n+i];
}
n += M;
int m[200][200] = {0};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (h[i] < h[j] && r[i] < r[j]) {
m[i][j] = -1;
}
}
}
int ans = 0;
for (int k = 0; k < n; ++k) for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {
if (m[i][k] && m[k][j]) {
m[i][j] = min(m[i][j], m[i][k] + m[k][j]);
}
ans = min(ans, m[i][j]);
}
cout << (-ans + 1) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
EACH(x,vec) is >> x;
return is;
}
/*
template<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
if (i) os << " ";
os << get<0>(t);
}
return os;
}
*/
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
REP(i,vec.size()) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
REP(i,vec.size()) {
if (i) os << endl;
os << vec[i];
}
return os;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int N;
while ( cin >> N, N ) {
vector<P> v;
REP(i, N) {
int h, r; cin >> h >> r;
v.pb( P(h, r) );
}
int M; cin >> M;
REP(i, M) {
int h, r; cin >> h >> r;
v.pb( P(h, r) );
}
sort( ALL(v) );
N += M;
vector< vector<int> > dp(N+1, vector<int>(N+1, -1)); dp[0][0] = 0;
REP(i, N) {
REP(j, N+1) {
if (dp[i][j] < 0) continue;
dp[i+1][j] = max(dp[i+1][j], dp[i][j]);
if (j == 0 || (v[j-1].first < v[i].first && v[j-1].second < v[i].second)) {
dp[i+1][i+1] = max(dp[i+1][i+1], dp[i][j]+1);
}
}
}
int ans = -1;
REP(i, N+1) ans = max(ans, dp[N][i]);
cout << ans << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
体育祭Sport Meet
=============
秋の体育祭が行われます。種目は徒競走、ボール運び、障害物競走、リレーの4種目です。参加チームは n チームで、この4種目の合計タイムが最も小さいチームが「優勝」、次に小さいチームが「準優勝」、そして、最下位より2番目のチームを「ブービー賞」として表彰したいと思います。
各チームの成績を入力として、「優勝」、「準優勝」、「ブービー賞」のチームを出力するプログラムを作成してください。
ただし、チームにはそれぞれ 1 から n のチーム番号が割り当てられています。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
record1
record2
:
recordn
```
１行目に対象となるチームの数 n (4 ≤ n ≤ 100000)、続く n 行に i 番目のチームの情報が与えられます。各チームの情報は以下の形式で与えられます。
```
id m1 s1 m2 s2 m3 s3 m4 s4
```
id (1 ≤ id ≤ n)はチーム番号、m1, s1 はそれぞれ徒競走のタイムの分と秒、m2, s2 はそれぞれボール運びのタイムの分と秒、m3, s3 はそれぞれ障害物競走のタイムの分と秒、m4, s4 はそれぞれリレーのタイムの分と秒を表します。分と秒はともに0 以上 59 以下の整数です。また、合計タイムが複数のチームで同じになるような入力はないものとします。
Output
------
入力データセットごとに以下の形式でチーム番号を出力します。
1 行目 優勝のチーム番号
2 行目 準優勝のチーム番号
3 行目 ブービー賞のチーム番号
Sample Input
------------
```
8
34001 3 20 3 8 6 27 2 25
20941 3 5 2 41 7 19 2 42
90585 4 8 3 12 6 46 2 34
92201 3 28 2 47 6 37 2 58
10001 3 50 2 42 7 12 2 54
63812 4 11 3 11 6 53 2 22
54092 3 33 2 54 6 18 2 19
25012 3 44 2 58 6 45 2 46
4
1 3 23 1 23 1 34 4 44
2 5 12 2 12 3 41 2 29
3 5 24 1 24 2 0 3 35
4 4 49 2 22 4 41 4 23
0
```
Output for the Sample Input
---------------------------
```
54092
34001
10001
1
3
2
```
| #include<iostream>
#include<algorithm>
using namespace std;
#define MAX 1000000
int n;
pair<int, int> T[MAX];
main(){
int id, m, s;
while( cin >> n && n ){
for ( int i = 0; i < n; i++ ){
cin >> id;
int sum = 0;
for ( int j = 0; j < 4; j++ ){
cin >> m >> s;
sum += m*60 + s;
}
T[i] = make_pair(sum, id);
}
sort( T, T + n );
cout << T[0].second << endl;
cout << T[1].second << endl;
cout << T[n-2].second << endl;
}
} | #include<cstdio>
#define MAX 100000
#define INF (1<<21)
int id[MAX], total[MAX];
int n;
int searchMin(){
int minv = INF;
int target;
for ( int i = 0; i < n; i++ ){
if ( total[i] < 0 ) continue;
if ( total[i] < minv ){
minv = total[i];
target = i;
}
}
total[target] = -1;
return id[target];
}
int searchMax(){
int maxv = 0;
int target;
for ( int i = 0; i < n; i++ ){
if ( total[i] < 0 ) continue;
if ( total[i] > maxv ){
maxv = total[i];
target = i;
}
}
total[target] = -1;
return id[target];
}
main(){
int m, s;
while(1){
scanf("%d", &n);
if ( n == 0 ) break;
for ( int i = 0; i < n; i++ ){
scanf("%d", &id[i]);
total[i] = 0;
for ( int j = 0; j < 4; j++ ){
scanf("%d %d", &m, &s);
total[i] += m*60+s;
}
}
printf("%d\n", searchMin());
printf("%d\n", searchMin());
searchMax();
printf("%d\n", searchMax());
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
観音堂
===
一郎君の家の裏山には観音堂があります。この観音堂まではふもとから 30 段の階段があり、一郎君は、毎日のように観音堂まで遊びに行きます。一郎君は階段を１足で３段まで上がることができます。遊んでいるうちに階段の上り方の種類（段の飛ばし方の個数）が非常にたくさんあることに気がつきました。
そこで、一日に 10 種類の上り方をし、すべての上り方を試そうと考えました。しかし数学を熟知しているあなたはそんなことでは一郎君の寿命が尽きてしまうことを知っているはずです。
一郎君の計画が実現不可能であることを一郎君に納得させるために、階段の段数 n を入力とし、一日に 10 種類の上り方をするとして、一郎君がすべての上り方を実行するのに要する年数を出力するプログラムを作成してください。一年は 365 日として計算してください。一日でも必要なら一年とします。365 日なら 1 年であり、366 日なら 2 年となります。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、段数を表す１つの整数 n (1 ≤ n ≤ 30) が１行に与えられます。
データセットの数は 30 を超えません。
Output
------
データセットごとに一郎君がすべての上り方を実行するのに必要な年数（整数）を１行に出力します。
Sample Input
------------
```
1
10
20
25
0
```
Output for the Sample Input
---------------------------
```
1
1
34
701
```
| #include<iostream>
using namespace std;
class Answer
{
public:
Answer(){day = 10; year = 365;}
int N; //??\???
int day;
int year;
unsigned long long count(int cnt); //??¨??¢?´¢(???)
void set(); //??\???
void OutPut(); //???????????????
bool empty(); //???????????¶?????????
bool ans(); //?§£???
};
unsigned long long Answer::count(int cnt)
{
if( cnt < 0)
return 0;
else if(cnt == 0)
return 1;
return count(cnt - 1) + count(cnt - 2) + count(cnt - 3);
}
void Answer::OutPut()
{
if( N == 0 )
return;
int ans_ = 1; //??????????????´???
ans_ += (count( N )) / (day * year); //??\???
cout << ans_ << endl;;
}
void Answer::set()
{
cin >> N;
}
bool Answer::empty()
{
if( N == 0 )return false;
else return true;
}
bool Answer::ans()
{
set();
OutPut();
return empty();
}
int main()
{
Answer ans;
while( ans.ans() );
return 0;
} | #include<iostream>
using namespace std;
#define MEMO_MAX 100
typedef unsigned long long ULL;
bool Flag_memo_g = true; //?????¢??????????????????
class Answer
{
public:
Answer()
{
day = 10; year = 365;
for(int i = 0; i < MEMO_MAX; i++)
{
memo[i] = 0;
Flag_memo[i] = false;
}
}
int N; //??\???
int day;
int year;
ULL memo[MEMO_MAX];
bool Flag_memo[MEMO_MAX];
ULL count(int cnt); //??¨??¢?´¢(??±???)
ULL count_memo(int cnt); //??¨??¢?´¢(??±???)(?????¢???ver.)
void set(); //??\???
void OutPut(); //???????????????
bool empty(); //???????????¶?????????
bool ans(); //?§£???
};
ULL Answer::count(int cnt)
{
if( cnt < 0 )
return 0;
else if( cnt == 0 )
return 1;
return count(cnt - 1) + count(cnt - 2) + count(cnt - 3);
}
ULL Answer::count_memo(int cnt)
{
if( cnt < 0 )return 0;
else if( cnt == 0 )return 1;
if( !(Flag_memo[cnt]) )
{
memo[cnt] = count_memo(cnt - 1) + count_memo(cnt - 2) + count_memo(cnt - 3);
Flag_memo[cnt] = true;
}
return memo[cnt];
}
void Answer::OutPut()
{
if( N == 0 )
return;
int ans_ = 1; //??????????????´???
if( Flag_memo_g )
ans_ += count_memo( N ) / (day * year);
else if( !Flag_memo_g )
ans_ += (count( N )) / (day * year); //??\???
cout << ans_ << endl;
}
void Answer::set()
{
cin >> N;
}
bool Answer::empty()
{
if( N == 0 )return false;
else return true;
}
bool Answer::ans()
{
set();
OutPut();
return empty();
}
int main()
{
Answer ans;
while( ans.ans() );
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
観音堂
===
一郎君の家の裏山には観音堂があります。この観音堂まではふもとから 30 段の階段があり、一郎君は、毎日のように観音堂まで遊びに行きます。一郎君は階段を１足で３段まで上がることができます。遊んでいるうちに階段の上り方の種類（段の飛ばし方の個数）が非常にたくさんあることに気がつきました。
そこで、一日に 10 種類の上り方をし、すべての上り方を試そうと考えました。しかし数学を熟知しているあなたはそんなことでは一郎君の寿命が尽きてしまうことを知っているはずです。
一郎君の計画が実現不可能であることを一郎君に納得させるために、階段の段数 n を入力とし、一日に 10 種類の上り方をするとして、一郎君がすべての上り方を実行するのに要する年数を出力するプログラムを作成してください。一年は 365 日として計算してください。一日でも必要なら一年とします。365 日なら 1 年であり、366 日なら 2 年となります。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、段数を表す１つの整数 n (1 ≤ n ≤ 30) が１行に与えられます。
データセットの数は 30 を超えません。
Output
------
データセットごとに一郎君がすべての上り方を実行するのに必要な年数（整数）を１行に出力します。
Sample Input
------------
```
1
10
20
25
0
```
Output for the Sample Input
---------------------------
```
1
1
34
701
```
| #include <iostream>
#include <string>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
int func(int kaidan,int now){
int a=0,b=0,c=0;
if(now==kaidan){
return 1;
}else if(now>kaidan){
return 0;
}else{
a+=func(kaidan,now+1);
b+=func(kaidan,now+2);
c+=func(kaidan,now+3);
}
return a+b+c;
}
int main(){
int n,ans;
while(cin>>n){
if(n==0)break;
ans=func(n,0);
cout<<ans/10/365+1<<endl;
}
return 0;
} | #include <iostream>
using namespace std;
int memo[31];
int main(){
int n,ans;
memo[0]=1;
memo[1]=1;
memo[2]=2;
for(int i=3;i<31;i++){
memo[i]=memo[i-1]+memo[i-2]+memo[i-3];
}
while(cin>>n){
if(n==0)break;
cout<<memo[n]/(365*10)+1<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
観音堂
===
一郎君の家の裏山には観音堂があります。この観音堂まではふもとから 30 段の階段があり、一郎君は、毎日のように観音堂まで遊びに行きます。一郎君は階段を１足で３段まで上がることができます。遊んでいるうちに階段の上り方の種類（段の飛ばし方の個数）が非常にたくさんあることに気がつきました。
そこで、一日に 10 種類の上り方をし、すべての上り方を試そうと考えました。しかし数学を熟知しているあなたはそんなことでは一郎君の寿命が尽きてしまうことを知っているはずです。
一郎君の計画が実現不可能であることを一郎君に納得させるために、階段の段数 n を入力とし、一日に 10 種類の上り方をするとして、一郎君がすべての上り方を実行するのに要する年数を出力するプログラムを作成してください。一年は 365 日として計算してください。一日でも必要なら一年とします。365 日なら 1 年であり、366 日なら 2 年となります。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、段数を表す１つの整数 n (1 ≤ n ≤ 30) が１行に与えられます。
データセットの数は 30 を超えません。
Output
------
データセットごとに一郎君がすべての上り方を実行するのに必要な年数（整数）を１行に出力します。
Sample Input
------------
```
1
10
20
25
0
```
Output for the Sample Input
---------------------------
```
1
1
34
701
```
| #include <iostream>
using namespace std;
int n;
int saiki(int ima)
{
if(ima == n)
return 1;
if(ima > n)
return 0;
int res = 0;
res += saiki(ima + 1) + saiki(ima + 2) + saiki(ima + 3);
return res;
}
int main() {
while (true){
cin >> n;
if (n == 0)
break;
int ans,a;
ans = saiki(0);
a = ans;
ans /= 3650;
a %= 3650;
if( a == 0 )
{
cout << ans << endl;
}
else if( a != 0 )
{
ans++;
cout << ans << endl;
}
}
} | #include <iostream>
using namespace std;
int main()
{
int n, cnt, y;
int c[31];
c[0] = 1;
c[1] = 1;
c[2] = 2;
for( int i=3; i<=30; i++ )
c[i] = c[i-1] + c[i-2] + c[i-3];
while( cin >> n, n != 0 ){
y = c[n]/(365*10);
y += !( c[n]%(365*10) == 0 );
cout << y << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
観音堂
===
一郎君の家の裏山には観音堂があります。この観音堂まではふもとから 30 段の階段があり、一郎君は、毎日のように観音堂まで遊びに行きます。一郎君は階段を１足で３段まで上がることができます。遊んでいるうちに階段の上り方の種類（段の飛ばし方の個数）が非常にたくさんあることに気がつきました。
そこで、一日に 10 種類の上り方をし、すべての上り方を試そうと考えました。しかし数学を熟知しているあなたはそんなことでは一郎君の寿命が尽きてしまうことを知っているはずです。
一郎君の計画が実現不可能であることを一郎君に納得させるために、階段の段数 n を入力とし、一日に 10 種類の上り方をするとして、一郎君がすべての上り方を実行するのに要する年数を出力するプログラムを作成してください。一年は 365 日として計算してください。一日でも必要なら一年とします。365 日なら 1 年であり、366 日なら 2 年となります。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、段数を表す１つの整数 n (1 ≤ n ≤ 30) が１行に与えられます。
データセットの数は 30 を超えません。
Output
------
データセットごとに一郎君がすべての上り方を実行するのに必要な年数（整数）を１行に出力します。
Sample Input
------------
```
1
10
20
25
0
```
Output for the Sample Input
---------------------------
```
1
1
34
701
```
| #include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef long long ll;
typedef unsigned long long ull;
#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); i++ )
#define UREP( i, m, n ) for ( unsigned int i = (unsigned int)( m ); i < (unsigned int)( n ); i++ )
#define ITER( c ) __typeof( (c).begin() )
#define IREP( c, it ) for ( ITER(c) it = c.begin(); it != c.end(); ++it )
#define ALL( c ) (c).begin(), (c).end()
#define RALL( c ) (c).rbegin(), (c).rend()
#define PB( n ) push_back( n )
#define MP( a, b ) make_pair( ( a ), ( b ) )
#define EXIST( c, e ) ( (c).find( e ) != (c).end() )
#define fst first
#define snd second
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
#define DEBUG( x ) cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << ( x ) << endl
VI memo;
int solve( int n )
{
if ( n == 0 )
{
return 1;
}
else if ( n < 0 )
{
return 0;
}
if ( memo[n] != -1 )
{
return memo[n];
}
return solve( n - 1 ) + solve( n - 2 ) + solve( n - 3 );
}
int main()
{
while ( true )
{
int n;
cin >> n;
if ( n == 0 )
{
break;
}
memo.resize( n + 1 );
fill( ALL( memo ), -1 );
cout << solve( n ) / 3650 + 1 << endl;
}
return 0;
} | #include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef long long ll;
typedef unsigned long long ull;
#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); i++ )
#define UREP( i, m, n ) for ( unsigned int i = (unsigned int)( m ); i < (unsigned int)( n ); i++ )
#define ITER( c ) __typeof( (c).begin() )
#define IREP( c, it ) for ( ITER(c) it = c.begin(); it != c.end(); ++it )
#define ALL( c ) (c).begin(), (c).end()
#define RALL( c ) (c).rbegin(), (c).rend()
#define PB( n ) push_back( n )
#define MP( a, b ) make_pair( ( a ), ( b ) )
#define EXIST( c, e ) ( (c).find( e ) != (c).end() )
#define fst first
#define snd second
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
#define DEBUG( x ) cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << ( x ) << endl
VI memo;
int solve( int n )
{
if ( n == 0 )
{
return 1;
}
else if ( n < 0 )
{
return 0;
}
if ( memo[n] != -1 )
{
return memo[n];
}
return memo[n] = solve( n - 1 ) + solve( n - 2 ) + solve( n - 3 );
}
int main()
{
while ( true )
{
int n;
cin >> n;
if ( n == 0 )
{
break;
}
memo.resize( n + 1 );
fill( ALL( memo ), -1 );
cout << solve( n ) / 3650 + 1 << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ランチ
===
お昼に食べるお弁当を作るために、お店で食べ物を買いました。お店では、食べ物を入れるのに細長い袋しかもらえなかったので、すべての食べ物を縦に積んで袋に入れる必要があります。袋が倒れにくいように、できるだけ重い物を下にして詰めたいのですが、食べ物の中にはやわらかい物もあって、上に重い物を乗せるとつぶれてしまいます。
そこで、食べ物の情報を入力とし、全ての食べ物がつぶれず、かつ全体の重心が最も低くなるような積み方を出力するプログラムを作成してください。それぞれの食べ物ごとに、名前 f、重さ w、上に載せて耐えられる重さ s が指定されます。
「全ての食べ物がつぶれない」というのは、下から順に、（f1、f2、... 、fn）と n 個の食べ物を積んだ時、すべての f について、
sfi ≥ wfi+1 + wfi+2 + ... + wfn
であることを意味します。また、全体の重心 G は、
G = (1 × wf1 + 2 × wf2 + ... + n × wfn) / (wf1 + wf2+ ... +wfn)
とします。ただし、解はちょうど1つだけ存在するものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。
```
n
f1 w1 s1
f2 w2 s2
:
fn wn sn
```
１行目に食べ物の個数 n (1 ≤ n ≤ 10)、続く n 行に i 番目の食べ物の名前 fi (20 文字以内の半角英文字列)、重さ wi (1 ≤ wi ≤ 1000)、耐えられる重さ si (1 ≤ si ≤ 1000) が空白区切りで与えられます。
データセットの数は 20 を超えません。
Output
------
データセットごとに、次の形式で食べ物の名前を下から積み上げる順に出力します。
1 行目: 1 番下の食べ物の名前（半角英文字列）
2 行目: 下から2 番目の食べ物の名前
：
n 行目: 1 番上の食べ物の名前
Sample Input
------------
```
4
sandwich 80 120
apple 50 200
cheese 20 40
cake 100 100
9
onigiri 80 300
onigiri 80 300
anpan 70 280
mikan 50 80
kanzume 100 500
chocolate 50 350
cookie 30 80
purin 40 400
cracker 40 160
0
```
Output for the Sample Input
---------------------------
```
apple
cake
sandwich
cheese
kanzume
purin
chocolate
onigiri
onigiri
anpan
mikan
cracker
cookie
```
| #include <cstdio>
#include <cfloat>
using namespace std;
char f[10][21];
int n, w[10], s[10], a[10], b[10];
bool u[10];
double maxg;
void dfs(int x, int tw, int m, double g) {
if (m == n) {
if (maxg < g) {
maxg = g;
for (int i=0; i<n; i++) {
b[i] = a[i];
}
}
return;
}
if (x>=n) {
return;
}
if (!u[x] && tw <= s[x]) {
u[x] = true;
tw += w[x];
a[m] = x;
dfs(0, tw, m+1, g + w[x]*(m+1));
tw -= w[x];
u[x] = false;
}
dfs(x+1, tw, m, g);
}
int main() {
while (1) {
scanf("%d", &n);
if (!n) break;
for (int i=0; i<n; i++) {
scanf("%s %d %d", f[i], &w[i], &s[i]);
}
for (int i=0; i<n; i++) {
u[i] = false;
}
maxg = -DBL_MAX;
dfs(0, 0, 0, 0.);
for (int i=n-1; i>=0; i--) {
printf("%s\n", f[b[i]]);
}
}
return 0;
} | #include <cstdio>
#include <algorithm>
using namespace std;
struct C {
int id;
int w;
int s;
static bool compare(const C &l, const C &r) {
if (l.w > r.w) {
return true;
} else if (l.w < r.w) {
return false;
} else {
return (l.s > r.s);
}
}
};
int main() {
C c[10];
char f[10][21];
int n, tw, a[10];
bool u[10];
while (1) {
scanf("%d", &n);
if (!n) break;
for (int i=0; i<n; i++) {
c[i].id = i;
scanf("%s %d %d", f[i], &c[i].w, &c[i].s);
}
sort(c, c+n, C::compare);
tw = 0;
for (int i=0; i<n; i++) {
tw += c[i].w;
}
for (int i=0; i<n; i++) {
u[i] = false;
}
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
if (!u[j] && tw - c[j].w <= c[j].s) {
tw -= c[j].w;
a[i] = c[j].id;
u[j] = true;
break;
}
}
}
for (int i=0; i<n; i++) {
printf("%s\n", f[a[i]]);
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ランチ
===
お昼に食べるお弁当を作るために、お店で食べ物を買いました。お店では、食べ物を入れるのに細長い袋しかもらえなかったので、すべての食べ物を縦に積んで袋に入れる必要があります。袋が倒れにくいように、できるだけ重い物を下にして詰めたいのですが、食べ物の中にはやわらかい物もあって、上に重い物を乗せるとつぶれてしまいます。
そこで、食べ物の情報を入力とし、全ての食べ物がつぶれず、かつ全体の重心が最も低くなるような積み方を出力するプログラムを作成してください。それぞれの食べ物ごとに、名前 f、重さ w、上に載せて耐えられる重さ s が指定されます。
「全ての食べ物がつぶれない」というのは、下から順に、（f1、f2、... 、fn）と n 個の食べ物を積んだ時、すべての f について、
sfi ≥ wfi+1 + wfi+2 + ... + wfn
であることを意味します。また、全体の重心 G は、
G = (1 × wf1 + 2 × wf2 + ... + n × wfn) / (wf1 + wf2+ ... +wfn)
とします。ただし、解はちょうど1つだけ存在するものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。各データセットは以下の形式で与えられます。
```
n
f1 w1 s1
f2 w2 s2
:
fn wn sn
```
１行目に食べ物の個数 n (1 ≤ n ≤ 10)、続く n 行に i 番目の食べ物の名前 fi (20 文字以内の半角英文字列)、重さ wi (1 ≤ wi ≤ 1000)、耐えられる重さ si (1 ≤ si ≤ 1000) が空白区切りで与えられます。
データセットの数は 20 を超えません。
Output
------
データセットごとに、次の形式で食べ物の名前を下から積み上げる順に出力します。
1 行目: 1 番下の食べ物の名前（半角英文字列）
2 行目: 下から2 番目の食べ物の名前
：
n 行目: 1 番上の食べ物の名前
Sample Input
------------
```
4
sandwich 80 120
apple 50 200
cheese 20 40
cake 100 100
9
onigiri 80 300
onigiri 80 300
anpan 70 280
mikan 50 80
kanzume 100 500
chocolate 50 350
cookie 30 80
purin 40 400
cracker 40 160
0
```
Output for the Sample Input
---------------------------
```
apple
cake
sandwich
cheese
kanzume
purin
chocolate
onigiri
onigiri
anpan
mikan
cracker
cookie
```
| #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int n;
vector<int> w, s;
vector<bool> used;
vector<int> bestIndex;
int bestG;
void solve(int k, vector<int>& index, int g, int sumW)
{
if(k == n){
if(g < bestG){
bestG = g;
bestIndex = index;
}
return;
}
for(int i=0; i<n; ++i){
if(used[i])
continue;
used[i] = true;
if(s[i] >= sumW){
index[k] = i;
solve(k+1, index, g+(n-k)*w[i], sumW+w[i]);
}
used[i] = false;
}
}
int main()
{
for(;;){
cin >> n;
if(n == 0)
return 0;
vector<string> name(n);
w.resize(n);
s.resize(n);
for(int i=0; i<n; ++i)
cin >> name[i] >> w[i] >> s[i];
bestG = INT_MAX;
used.assign(n, false);
vector<int> index(n);
solve(0, index, 0, 0);
for(int i=n-1; i>=0; --i)
cout << name[bestIndex[i]] << endl;
}
} | #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
class Data
{
public:
int w, s;
string name;
bool operator<(const Data& d) const{
return s < d.s;
}
};
int n;
vector<Data> d;
vector<bool> used;
vector<int> bestIndex;
int bestG;
void solve(int k, vector<int>& index, int g, int sumW)
{
if(k == n){
if(g < bestG){
bestG = g;
bestIndex = index;
}
return;
}
for(int i=0; i<n; ++i){
if(used[i])
continue;
if(d[i].s >= sumW){
used[i] = true;
index[k] = i;
solve(k+1, index, g+(n-k)*d[i].w, sumW+d[i].w);
used[i] = false;
}else{
return;
}
}
}
int main()
{
for(;;){
cin >> n;
if(n == 0)
return 0;
d.resize(n);
for(int i=0; i<n; ++i)
cin >> d[i].name >> d[i].w >> d[i].s;
sort(d.begin(), d.end());
bestG = INT_MAX;
used.assign(n, false);
vector<int> index(n);
solve(0, index, 0, 0);
for(int i=n-1; i>=0; --i)
cout << d[bestIndex[i]].name << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
便利な町
====
来春卒業するAさんは、就職を機に引越しをすることにしました。就職する会社は、オフィスがいくつかの町にあって、日によって出勤するオフィスが違います。そこでAさんは,どこのオフィスに
行くにも時間の短い町に住もうと考えました。
そこであなたは、Aさんを助けるため、住むのに一番便利な町を探すことになりました。
町には 0 から始まる番号が振られており、町と町の間には道があります。それぞれの道に対して通勤時間が決まっています。Aさんがある町に住んでいる場合に、自分の町のオフィスまでの通勤時間は 0 とします。このときに全ての町までの通勤時間の総和を考えます。例えば、町と道の配置が上の図のようになっていて、Aさんが町1に住んだ場合には、それぞれの町までの通勤時間は
町 0 まで 80
町 1 まで 0
町 2 まで 20
町 3 まで 70
町 4 まで 90
となり、総和は 260 となります。
道の数と、全ての道の情報を入力とし、それぞれの町に住んだ場合の通勤時間の総和を計算し、それが最小となる町の番号と、そのときの通勤時間の総和を出力するプログラムを作成してください。ただし、通勤時間の総和が最小となる町が複数ある場合は、一番小さい町の番号及びその時の通勤時間の総和を出力してください。町の総数は 10 以下、道の総数は 45 以下とし、全ての道は双方向に移動でき、通勤時間は方向によって変わらないものとします。また、どの町からでもその他全ての町への 経路があるものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。 各データセットは以下の形式で与えられます。
```
n
a1 b1 c1
a2 b2 c2
:
an bn cn
```
１行目に道の数 n (1 ≤ n ≤ 45) が与えられます。続く n 行に i 番目の道の情報が与えられます。
ai, bi (0 ≤ ai, bi ≤ 9) は i 番目の道がつないでいる町の番号、ci (0 ≤ ci ≤ 100) はその道の通勤時間を表します。
Output
------
データセット毎に、通勤時間の総和が最小になる町の番号及びその時の通勤時間の総和を空白区切りで１行に出力します。
Sample Input
------------
```
6
0 1 80
1 2 20
0 2 60
2 3 50
3 4 60
1 4 90
2
0 1 1
1 2 1
0
```
Output for the Sample Input
---------------------------
```
2 240
1 2
```
| #include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<cctype>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long LL;
#define N 2010
#define INF 0x3f3f3f
int n;
int maps[N][N];
int dist[N], vis[N];
void Init(int m)
{
for(int i=0; i<=m; i++)
for(int j=0; j<=m; j++)
maps[i][j]=i==j ? 0 : INF;
}
void dij(int s, int m)
{
for(int i=0; i<=m; i++)
dist[i]=maps[s][i];
memset(vis, 0, sizeof(vis));
vis[s]=1;
for(int i=0; i<=m; i++)
{
int Min=INF, index=-1;
for(int j=0; j<=m; j++)
{
if(!vis[j]&&dist[j]<Min)
{
Min=dist[j];
index=j;
}
}
if(index==-1) continue;
vis[index]=1;
for(int j=0; j<=m; j++)
{
if(!vis[j]&&dist[j]>Min+maps[index][j])
dist[j]=Min+maps[index][j];
}
}
}
int main()
{
int a, b, c, Max, index, sum;
while(scanf("%d", &n), n)
{
Init(1100);
Max=-1;
for(int i=1; i<=n; i++)
{
scanf("%d%d%d", &a, &b, &c);
maps[a][b]=maps[b][a]=min(maps[a][b], c);
Max=max(Max, a);
Max=max(Max, b);
}
int s;
sum=INF;
for(int i=0; i<=Max; i++)
{
dij(i, Max);
s=0;
for(int j=0; j<=Max; j++)
s+=dist[j];
if(s<sum)
{
index=i;
sum=s;
}
}
printf("%d %d\n", index, sum);
}
return 0;
} | #include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
int t,map[12][12],sum,ans,s,i,j,k,max0,a,b,c;
while(scanf("%d",&t) && t)
{
memset(map,1,sizeof(map));
max0=0;
for(i=0;i<t;i++)
{
scanf("%d %d %d",&a,&b,&c);
map[a][b]=map[b][a]=c;
max0=max(max0,max(a,b));
}
/* printf("%d\n\n",max0);
for(i=0;i<=max0;i++)
{
for(j=0;j<=max0;j++)
{
printf("%d ",map[i][j]);
if(j == max0)
printf("\n");
}
}*/
for(k=0;k<=max0;k++)
{
for(i=0;i<=max0;i++)
{
for(j=0;j<=max0;j++)
{
map[i][j]=min(map[i][j],map[i][k]+map[k][j]);
}
}
}
sum=10000000,ans=0;
for(i=0;i<=max0;i++)
{
s=0;
for(j=0;j<=max0;j++)
{
if(i != j)
{
s+=map[i][j];
}
}
if(s < sum)
{
sum=s;
ans=i;
}
}
printf("%d %d\n",ans,sum);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
#define INF 999999999
int main(){
double g[110][110];
rep(i,110)rep(j,110)g[i][j]=-1;
int n,m;
while(cin>>n>>m){
if(n==0&&m==0)break;
rep(i,n){
rep(j,n){
cin>>g[i][j];
}
}
double dp[110][110];
rep(i,110)rep(j,110)dp[i][j] = -1;
rep(i,n)dp[1][i]=1.0;
for(int i=2;i<=m;i++){
for(int j=0;j<n;j++){
for(int k=0;k<n;k++){
dp[i][j] = max(dp[i][j],dp[i-1][k]*g[k][j]);
}
}
}
double ans = -1;
rep(i,n){
ans = max(ans,dp[m][i]);
}
printf("%.2lf\n",ans);
}
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define vi vector<int>
#define pb push_back
#define INF 999999999
//#define INF (1LL<<59)
int main(){
int n,m;
while(cin>>n>>m&&(n||m)){
double table[101][101];
rep(i,n) rep(j,n) cin>>table[i][j];
double dp[101][101];
rep(i,101)rep(j,101)dp[i][j] = -1;
rep(i,n) dp[0][i] = 1;
for(int i=1;i<m;i++){
rep(j,n){
rep(k,n){
dp[i][j] = max( dp[i-1][k]*table[k][j] , dp[i][j] );
}
}
}
double ans = -1;
rep(i,n){
ans = max(ans,dp[m-1][i]);
}
printf("%.2lf\n",ans);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN | |
#include <iostream>
#include <queue>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef pair<pair<int,int>,int> NODE;
#define X first.second
#define Y first.first
#define depth second
/*ï*/
int ox[] = {-1, 1, 0, 0, 1,1};
int oy[] = { 0, 0,-1, 1,-1,1};
/*ô*/
int ex[] = {-1, 1, 0, 0,-1,-1};
int ey[] = { 0, 0,-1, 1,-1, 1};
int main(){
int point[100][100];
int h,w,a,b,t,x,y,s;
while(cin >> w && w){
int ret = 0;
cin >> h;
rep(i,100)rep(j,100)point[i][j] = 0;
cin >> t;
rep(i,t){
cin >> a >> b;
a--;b--;
point[b][a] = i+1;
}
cin >> s;
rep(P,s){
cin >> a >> b;
a--;b--;
point[b][a] = 50;
//rep(i,h){rep(j,w)cout << point[i][j];cout << endl;}
int pt[100] = {0};
rep(i,h)rep(j,w){
x = j,y = i;
queue<NODE> Q;
pair<int,int> dp[100];
bool done[100][100]={0};
Q.push( make_pair(make_pair(y,x),0 ) );
while( Q.size() ){
NODE q = Q.front(); Q.pop();
if(point[q.Y][q.X]){
dp[q.depth].first++;
dp[q.depth].second = point[q.Y][q.X];
}
if( q.Y % 2 == 1){
rep(L,6){
if( q.X+ox[L] >=0 && q.X+ox[L] < w && q.Y+oy[L] < h && q.Y+oy[L]>=0 ){
if( !done[q.Y+oy[L]][q.X+ox[L]] )Q.push( make_pair(make_pair(q.Y+oy[L],q.X+ox[L]),q.depth+1) );
done[q.Y+oy[L]][q.X+ox[L]] = true;
}
}
}else{
rep(L,6){
if( q.X+ex[L] >=0 && q.X+ex[L] < w && q.Y+ey[L] < h && q.Y+ey[L]>=0 ){
if( !done[q.Y+ey[L]][q.X+ex[L]] )Q.push( make_pair(make_pair(q.Y+ey[L],q.X+ex[L]),q.depth+1) );
done[q.Y+ey[L]][q.X+ex[L]] = true;
}
}
}
}
rep(I,100){
if(dp[I].first){
if(dp[I].first==1)
pt[dp[I].second-1]++;
break;
}
}
}
ret = max(pt[49],ret);
point[b][a] = 0;
}
cout << ret << endl;
}
} | #include <iostream>
#include <vector>
#include <cstdio>
#include <queue>
using namespace std;
struct NODE{
int x,y,c,num;
NODE(int x,int y,int c) : x(x) , y(y) , c(c) {}
NODE(int x,int y,int c,int num) : x(x) , y(y) , c(c) , num(num) {}
};
int W,H;
int doit(vector<NODE> v){
queue<NODE> Q;
for(int i = 0 ; i < v.size() ; i++){
Q.push(NODE(v[i].x,v[i].y,0,i));
}
int cnt[100][100]={};
int ans[100][100];
for(int i = 0 ; i < 100 ; i++)
for(int j = 0 ; j < 100 ; j++)
ans[i][j] = 1e9;
// kore Shindoinen!!!!!!!!!!!!!
// kore Shindoinen!!!!!!!!!!!!!
// kore Shindoinen!!!!!!!!!!!!!
int dx[2][6] = { {-1, 0, 1,-1,-1,0 } , {-1,0,0,1,1,1} };
int dy[2][6] = { { 0, 1, 0, 1,-1,-1} , {0,1,-1,0,1,-1} };
// kore Shindoinen!!!!!!!!!!!!!
// kore Shindoinen!!!!!!!!!!!!!
// kore Shindoinen!!!!!!!!!!!!!
while(Q.size()){
NODE q = Q.front(); Q.pop();
if( q.x < 0 || q.y < 0 || q.x >= W || q.y >= H ) continue;
if( ans[q.y][q.x] < q.c ) continue;
if( ans[q.y][q.x] > 10000) {
ans[q.y][q.x] = q.c;
cnt[q.y][q.x] = (1<<q.num);
}else if( ans[q.y][q.x] == q.c ){
cnt[q.y][q.x] |= (1<<q.num);
continue;
}
for(int i = 0 ; i < 6 ; i++){
Q.push(NODE(q.x+dx[q.y%2][i],q.y+dy[q.y%2][i],q.c+1,q.num));
}
}
int cntt = 0;
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
//printf("%3d",cnt[i][j]);
if( cnt[i][j] == (1<<(v.size()-1)) ){
cntt++;
}
}
//puts("");
}
return cntt;
}
int main(){
while(cin >> W >> H && W){
int s,N;
cin >> s;
vector<NODE> alr;
for(int i = 0 ; i < s ; i++){
int x,y;
cin >> x >> y;
x--,y--;
alr.push_back(NODE(x,y,0));
}
cin >> N;
int ans = 0;
for(int i = 0 ; i < N ; i++){
int x,y;
cin >> x >> y;
x--,y--;
alr.push_back(NODE(x,y,0));
ans = max( ans , doit(alr) );
alr.pop_back();
}
cout << ans << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN | |
立方体の作品
======
芸術家品川は n 点の作品を出展するように依頼されました。そこで、立方体の 6 面をペンキで色付けしたものを作品として出展することにしました。作品は、Red、Yellow、Blue、Magenta、Green、Cyan の 6 色全てが使われていて、各面は 1 色で塗りつぶされています。品川は形が同じ立方体の作品でも色の配置の仕方を変え、異なる作品として n 点作成しました。
彼の友人であるあなたは、友人のよしみで作品を出展前に閲覧させてもらいましたが、そこであることに気が付きました。それらの作品の中に異なる色付けをされているように見えても、実は同じ色の組み合わせをした立方体が存在していたのです。このままでは、 n 点の作品を出展することできなくなってしまいます。
作成した作品の数と各作品の色の情報を入力とし、出展するためにあと何点必要かを出力するプログラムを作成してください。
立方体の各面の色は c1 から c6 までの記号で表され、 以下のような配置となっています。また、c1 から c6 のそれぞれは Red、Yellow、Blue、Magenta、Green、Cyan のいずれか 1 色となります。
Input
-----
複数のデータセットの並びが入力として与えられます。 入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
cube1
cube2
:
cuben
```
１行目に作品の数 n (1 ≤ n ≤ 30)、続く n 行に i 番目の作品の情報が与えられます。各作品の情報は次の形式で与えられます。
```
c1 c2 c3 c4 c5 c6
```
作品の色の配置 ci が空白区切りで与えられます。
データセットの数は 100 を超えません。
Output
------
データセットごとに、出展するのにあと何点の作品が必要かを１行に出力します。
Sample Input
------------
```
3
Cyan Yellow Red Magenta Green Blue
Cyan Yellow Red Magenta Green Blue
Red Yellow Magenta Blue Green Cyan
4
Red Magenta Blue Green Yellow Cyan
Red Yellow Magenta Blue Green Cyan
Magenta Green Red Cyan Yellow Blue
Cyan Green Yellow Blue Magenta Red
0
```
Output for the Sample Input
---------------------------
```
1
1
```
| #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
#include<stack>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<string> vstring;
typedef vector<pint> vpint;
typedef stringstream SS;
struct Edge{int to,from,cost;};
#ifdef DEBUG
#define debug cout
#else
SS ss;
#define debug ss
#endif
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
#define rep(i,n) for(int i=0;i<(n);++i)
#define repn(i,m,n) for(int i=(m);i<=(n);++i)
#define repd(i,n) for(int i=(n)-1;i>=0;--i)
#define repnd(i,m,n) for(int i=(n);i>=(m);--i)
#define rep0(i,n) for(i=0;i<(n);++i)
#define repn0(i,m,n) for(i=(m);i<=(n);++i)
#define repd0(i,n) for(i=(n)-1;i>=0;--i)
#define repnd0(i,m,n) for(i=(n);i>=(m);--i)
#define all(n) n.begin(),n.end()
#define sz(n) ((int)(n).size())
#define IL for(;;)
#define MP make_pair
#define PB push_back
#define X second
#define Y first
#define PUTLINE debug<<"LINE:"<<__LINE__<<endl;
const int INF = 2147483647/3;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[]={1,-1,0,0,1,-1,1,-1,0};
const int dy[]={0,0,1,-1,1,-1,-1,1,0};
vstring h(vstring s,int n){
if(n==0)return s;
vstring ss;
ss.PB(s[0]);
ss.PB(s[3]);
ss.PB(s[1]);
ss.PB(s[4]);
ss.PB(s[2]);
ss.PB(s[5]);
return h(ss,n-1);
}
vstring g(vstring s,int n){
int pos[6][6]={
{0,1,2,3,4,5},
{1,5,2,3,0,4},
{2,1,5,0,4,3},
{3,1,0,5,4,2},
{4,0,2,3,5,1},
{5,4,2,3,1,0},
};
vstring res;
rep(i,6)res.PB(s[pos[n][i]]);
return res;
}
int main() {
IL{
int n;
cin>>n;
if(n==0)break;
vector<vstring> dice;
vstring rotdice[40][24];
rep(i,n){
string s;
vstring v;
rep(i,6){
cin>>s;
v.PB(s);
}
dice.PB(v);
}
rep(k,n){
rep(i,6){
vstring v=g(dice[k],i);
rep(j,4){
rotdice[k][i*4+j]=h(v,j);
}
}
}
int ng[40]={};
rep(i,n)repn(j,i+1,n-1){
rep(k,24){
if(rotdice[j][k]==dice[i])ng[j]=1;
}
}
int res=0;
rep(i,n)res+=ng[i];
cout<<res<<endl;
}
return 0;
} | #include<iostream>
#include<string>
#include<vector>
#define REP(i, b, n) for(int i = b; i<(int)n; i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
enum{TOP=0,FRONT,RIGHT,LEFT,BACK,BOTTOM};
#define rotate_swap(x,a,b,c,d) swap(x.m[a],x.m[b]);swap(x.m[b],x.m[c]);swap(x.m[c],x.m[d]);
const int dy[] = {-1, 0, 1, 0};
const int dx[] = {0, 1, 0, -1};
class Dice{
public:
int y, x;
string m[6];
Dice(){
y = x = 0;
}
bool operator<(const Dice &a)const{
rep(i,6)if (m[i] != a.m[i])return m[i] < a.m[i];
return false;
}
bool operator==(const Dice &a)const{
rep(i,6)if (m[i] != a.m[i])return false;
return true;
}
};
void rotate_r(Dice &x){
x.x++;
rotate_swap(x,TOP,LEFT,BOTTOM,RIGHT);
}
void rotate_l(Dice &x){
x.x--;
rotate_swap(x,TOP,RIGHT,BOTTOM,LEFT);
}
void rotate_f(Dice &x){
x.y--;
rotate_swap(x,TOP,BACK,BOTTOM,FRONT);
}
void rotate_b(Dice &x){
x.y++;
rotate_swap(x,TOP,FRONT,BOTTOM,BACK);
}
void rotate_cw(Dice &x){
rotate_swap(x,BACK,LEFT,FRONT,RIGHT);
}
void rotate_ccw(Dice &x){
rotate_swap(x,BACK,RIGHT,FRONT,LEFT);
}
vector<Dice> generate_all(Dice x){
vector<Dice> res;
rep(i,6){
rep(j,4){
res.push_back(x);
rotate_cw(x);
}
if (i%2 == 0)rotate_r(x);
else rotate_f(x);
}
return res;
}
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) break;
vector<vector<Dice> > v;
rep (i, n) {
Dice dice;
cin >> dice.m[TOP];
cin >> dice.m[FRONT];
cin >> dice.m[RIGHT];
cin >> dice.m[LEFT];
cin >> dice.m[BACK];
cin >> dice.m[BOTTOM];
v.push_back(generate_all(dice));
}
int res = 0;
rep (i, n) {
rep (j, i) rep (ii, 24) rep (jj, 24) {
if (v[i][ii] == v[j][jj]) {
++res;
goto next;
}
}
next:;
}
cout << res << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
青春の片道切符
=======
太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。
線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk
```
1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。
続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。
続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。
データセットの数は 50 を超えない。
Output
------
データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。
Sample Input
------------
```
6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0
```
Output for the Sample Input
---------------------------
```
450
35
```
| #include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<numeric>
#include<vector>
#include<cstdio>
#include<climits>
#include<cfloat>
#include<cstring>
#define foreach(t,p,tit) for(t::iterator tit=p.begin();tit!=p.end();++tit)
#define rforeach(t,p) for(t::reverse_iterator it=p.rbegin();it!=p.rend();++it)
#define all(p) p.begin(),p.end()
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int costs[1010][1010];
int times[1010][1010];
int d[1010];
#define INF 10000
struct E
{
int a,b,c;
E(){};
E(int a,int b,int c):a(a),b(b),c(c){};
};
#define MONEY 0
#define EKI 1
int main()
{
int n,m;
while(cin>>n>>m)
{
if(n==0&&m==0)break;
memset(costs,INF,sizeof(costs));
memset(times,INF,sizeof(times));
vector<E> cs;
vector<E> ts;
int a,b,c,t;
rep(i,n)
{
cin>>a>>b>>c>>t;
costs[a][b] = c; costs[b][a] = c;
times[a][b] = t; times[b][a] = t;
cs.push_back(E(a,b,c));
cs.push_back(E(b,a,c));
ts.push_back(E(a,b,t));
ts.push_back(E(b,a,t));
}
rep(i,m)
{
costs[i][i] = 0;
times[i][i] = 0;
}
int k,p,q,r;
cin>>k;
rep(i,k)
{
memset(d,INF,sizeof(d));
cin >> p >> q >> r;
d[p] = 0;
if(r==MONEY)
{
//rep(j,n*2){if(cs[j].a == p) d[cs[j].b] = cs[j].c;}
while(true)
{
bool update = false;
rep(j,n*2)
{
//cout <<"edge"<< j<<cs[j].a<<"to"<<cs[j].b << endl;
if( (d[ cs[j].a] != INF) && d[cs[j].b] > d[cs[j].a] + cs[j].c)
{
d[cs[j].b] = d[ cs[j].a] + cs[j].c;
update = true;
//cout << "updated" <<d[cs[j].b] <<endl;
}
}
if(!update)break;
}
cout << d[q]<<endl;
}
else
{
//rep(j,n*2){if(ts[j].a == p) d[ts[j].b] = ts[j].c;}
while(true)
{
bool update = false;
rep(j,n*2)
{
if(d[ ts[j].a] != INF && d[ts[j].b] > d[ts[j].a] + ts[j].c)
{
d[ts[j].b] = d[ ts[j].a] + ts[j].c;
update = true;
}
}
if(!update)break;
}
cout << d[q]<<endl;
}
}
}
return 0;
} | #include<iostream>
#include<cstring>
#include<vector>
using namespace std;
#define rep(i,n) for(int i=0;i<n;++i)
#define INF 300000
struct E
{
int a,b,c,t;
E(){};
E(int a,int b,int c,int t):a(a),b(b),c(c),t(t){};
};
//E cs[700];
unsigned int d[150];
int main()
{
int n,m,k,p,q,r;
while(cin >> n >> m)
{
if(n==0 && m==0)break;
vector<E> cs;
int ta,tb,tc,tt;
rep(i,n)
{
cin >> ta>>tb>>tc >>tt;
cs.push_back( E(ta,tb,tc,tt));
cs.push_back( E(tb,ta,tc,tt));
}
cin >> k;
rep(i,k)
{
memset(d,INF,150*sizeof(int));
cin >> p >> q >>r;
d[p] = 0;
bool update = false;
if(r==0)while(true)
{
update = false;
rep(j,n*2)
{
if(d[cs[j].a] != INF && d[cs[j].b] > d[cs[j].a] + cs[j].c)
{
update = true;
d[cs[j].b] = d[cs[j].a] + cs[j].c;
}
}
if(!update) break;
}
if(r==1)while(true)
{
update = false;
rep(j,n*2)
{
if(d[cs[j].a] != INF && d[cs[j].b] > d[cs[j].a] + cs[j].t)
{
update = true;
d[cs[j].b] = d[cs[j].a] + cs[j].t;
}
}
if(!update) break;
}
cout << d[q] << endl;
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
青春の片道切符
=======
太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。
線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk
```
1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。
続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。
続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。
データセットの数は 50 を超えない。
Output
------
データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。
Sample Input
------------
```
6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0
```
Output for the Sample Input
---------------------------
```
450
35
```
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <functional>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define chmin(a,b) a=min(a,b)
#define chmax(a,b) a=max(a,b)
#define rep(i,x) for(int i=0;i<(x);++i)
#define rep1(i,x) for(int i=1;i<=(x);++i)
#define rrep(i,x) for(int i=(x)-1;i>=0;--i)
#define rrep1(i,x) for(int i=(x);i>=1;--i)
#define FOR(i,a,x) for(int i=(a);i<(x);++i)
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
template<typename T>T&get(){T a;cin >> a;return a;}
template<typename T>T&rev(T&a){reverse(all(a));return a;}
template<typename T>istream&operator>>(istream&is,vector<T>&vec){rep(i,vec.size())is>>vec[i];return is;}
template<typename T>vector<T>&sort(vector<T>a){sort(all(a));return a;}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
const int inf = 1e9;
const ll linf = 3e18;
struct edge {
int to, cost, time;
edge(int to0,int cost0,int time0) {
to = to0; cost = cost0; time = time0;
};
};
int N, M;
vector<edge> G[100];
int d[100];
void dijkstra(int s, int mode)
{
priority_queue<pii, vector<pii>, greater<pii> > q;
fill(d, d + M, inf);
d[s] = 0;
q.push(MP(0, s));
while (q.size()) {
pii p = q.top(); q.pop();
int v = p.scd;
rep(u, G[v].size()) {
edge e = G[v][u];
int a = mode == 0 ? e.cost : e.time;
if (d[e.to] > d[v] + a) {
d[e.to] = d[v] + a;
q.push(MP(d[e.to], e.to));
}
}
}
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
while (cin >> N >> M, N || M) {
rep(i, M) G[i].clear();
rep(i, N) {
int a, b, cost, time; cin >> a >> b >> cost >> time; a--; b--;
G[a].PB(edge(b, cost, time));
G[b].PB(edge(a, cost, time));
}
int K; cin >> K;
rep(i, K) {
int p, q, r; cin >> p >> q >> r; p--; q--;
dijkstra(p, r);
cout << d[q] << endl;
}
}
} | #include <cstdio>
#include <algorithm>
using namespace std;
#define chmin(a,b) a=min(a,b)
#define rep(i,x) for(int i=0;i<(x);++i)
const int inf = 1e9;
int N, M;
int mc[100][100], mt[100][100];
void wf()
{
rep(k, M) rep(i, M) rep(j, M) {
chmin(mc[i][j], mc[i][k] + mc[j][k]);
chmin(mt[i][j], mt[i][k] + mt[j][k]);
}
}
int main()
{
while (scanf("%d %d", &N, &M), N || M) {
fill(mc[0], mc[M], inf);
fill(mt[0], mt[M], inf);
rep(i, M) mc[i][i] = mt[i][i] = 0;
rep(i, N) {
int a, b, cost, time; scanf("%d %d %d %d", &a, &b, &cost, &time); a--; b--;
mc[a][b] = mc[b][a] = cost;
mt[a][b] = mt[b][a] = time;
}
wf();
int K; scanf("%d", &K);
rep(i, K) {
int p, q, r; scanf("%d %d %d", &p, &q, &r); p--; q--;
printf("%d\n", r == 0 ? mc[p][q] : mt[p][q]);
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
青春の片道切符
=======
太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。
線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk
```
1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。
続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。
続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。
データセットの数は 50 を超えない。
Output
------
データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。
Sample Input
------------
```
6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0
```
Output for the Sample Input
---------------------------
```
450
35
```
| #include<algorithm>
#include<iostream>
const int INF = 1 << 29;
int n, m;
int d[2][3000][3000];
int main()
{
while( std::cin >> n >> m, n | m )
{
for( int i = 0; i != n; ++i )
for( int j = 0; j != n; ++j )
for( int k = 0; k != 2; ++k )
d[k][i][j] = i == j ? 0 : INF;
for( int i = 0; i != n; ++i )
{
int a, b, c, t;
std::cin >> a >> b >> c >> t;
d[0][a-1][b-1] = d[0][b-1][a-1] = c;
d[1][a-1][b-1] = d[1][b-1][a-1] = t;
}
for( int k = 0; k != m; ++k )
for( int i = 0; i != m; ++i )
for( int j = 0; j != m; ++j )
for( int l = 0; l != 2; ++l )
d[l][i][j] = std::min( d[l][i][j], d[l][i][k] + d[l][k][j] );
int k;
std::cin >> k;
while( k-- )
{
int p, q, r;
std::cin >> p >> q >> r;
std::cout << d[r][p-1][q-1] << std::endl;
}
}
return 0;
} | // AOJ 0200 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0200)
#include<cstdio>
#include<algorithm>
#include<limits>
#define rep(i,a) for(int i=0;i<(a);++i)
const int MAX_M = 100, INF = std::numeric_limits<int>::max()>>4;
int n, m;
int d[2][MAX_M][MAX_M];
int main()
{
while( scanf( "%d%d", &n, &m ), n|m )
{
rep( k, 2 ) rep( i, m ) rep( j, m )
d[k][i][j] = i==j?0:INF;
rep( i, n )
{
int a, b, c, t;
scanf( "%d%d%d%d", &a, &b, &c, &t );
--a; --b;
d[0][a][b] = d[0][b][a] = c;
d[1][a][b] = d[1][b][a] = t;
}
rep( r, 2 ) rep( k, m ) rep( i, m ) rep( j, m )
d[r][i][j] = std::min( d[r][i][j], d[r][i][k]+d[r][k][j] );
int k;
scanf( "%d", &k );
rep( i, k )
{
int p, q, r;
scanf( "%d%d%d", &p, &q, &r );
printf( "%d\n", d[r][p-1][q-1] );
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
青春の片道切符
=======
太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。
線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk
```
1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。
続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。
続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。
データセットの数は 50 を超えない。
Output
------
データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。
Sample Input
------------
```
6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0
```
Output for the Sample Input
---------------------------
```
450
35
```
| #include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n,m,a,b,cost,time,k,p,q,r;
int t[100][100],c[100][100];
for(;;){
cin >> n >> m;
if(!n && !m)break;
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
if(i==j){
t[i][j] = 0;
c[i][j] = 0;
}else{
t[i][j] = 1000000;
c[i][j] = 1000000;
}
}
}
for(int i=0;i<n;i++){
cin >> a >> b >> cost >> time;
t[a-1][b-1] = time;
t[b-1][a-1] = time;
c[a-1][b-1] = cost;
c[b-1][a-1] = cost;
}
for(int x=0;x<m;x++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
t[i][j] = min(t[i][j],t[i][x] + t[x][j]);
c[i][j] = min(c[i][j],c[i][x] + c[x][j]);
}
}
}
cin >> k;
for(int i=0;i<k;i++){
cin >> p >> q >> r;
if(r)cout << t[p-1][q-1] << endl;
else cout << c[p-1][q-1] << endl;
}
}
} | #include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int n,m,a,b,cost,time,k,p,q,r;
int t[100][100],c[100][100];
for(;;){
scanf("%d %d",&n,&m);
if(!n && !m)break;
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
if(i==j){
t[i][j] = 0;
c[i][j] = 0;
}else{
t[i][j] = 1000000;
c[i][j] = 1000000;
}
}
}
for(int i=0;i<n;i++){
scanf("%d %d %d %d",&a,&b,&cost,&time);
t[a-1][b-1] = time;
t[b-1][a-1] = time;
c[a-1][b-1] = cost;
c[b-1][a-1] = cost;
}
for(int x=0;x<m;x++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
t[i][j] = min(t[i][j],t[i][x] + t[x][j]);
c[i][j] = min(c[i][j],c[i][x] + c[x][j]);
}
}
}
scanf("%d",&k);
for(int i=0;i<k;i++){
scanf("%d %d %d",&p,&q,&r);
if(r)printf("%d\n",t[p-1][q-1]);
else printf("%d\n",c[p-1][q-1]);
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
上司のおごり
======
会津太郎さんの会社には、割り切れない事が大嫌いな上司がいます。太郎さんがその上司と食事に行くときは、割り勘で会計をしているのですが、支払金額が参加人数で割り切れないときは、いつも上司がおごってくれています。
ある日、太郎さんは食事会の幹事になりました。お金の少ない太郎さんは、その上司を誘ってなんとかおごってもらえるように出来ないか考えました。もう料理屋に注文をしなければならないのですが、まだ何人参加するかは分からないので、どんな人数が参加してもおごってもらえるような注文をしておきたいようです。太郎さんの同期で、同じく食事会に参加する予定のあなたは、太郎さんに協力して、予算額以下で最大のどんな人数でも割り切れない金額を算出することにしました。
料理の種類、各料理の料金、予算額を入力とし、予算額以下で最大のどんな数字でも割り切れない合計金額(ただし、 1 と合計金額は除く)を出力するプログラムを作成してください。なお、各種類の料理は複数個注文できますが、全種類の料理を注文する必要はありません。ただし、このような合計金額がない場合は、 NA と出力してください。
Input
-----
複数のデータセットの並びが入力として与えられます。 入力の終わりはゼロふたつの行で示されます。
各データセットは以下の形式で与えられます。
```
n x
v1
v2
:
vn
```
1 行目に料理の種類 n (1 ≤ n ≤ 30) と予算額 x (1 ≤ x ≤ 1000000) が空白区切りで与えられます。続くn 行に i 種類目の料理の金額を表す整数 vi (1 ≤ vi ≤ 1000000) が与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、予算額に最も近い合計金額、または NA を１行に出力します。
Sample Input
------------
```
4 15000
305
260
129
500
3 400
10
20
30
3 200909
5
9
12
0 0
```
Output for the Sample Input
---------------------------
```
14983
NA
200909
```
| #include<iostream>
#include<algorithm>
using namespace std;
bool dp[1000001];
bool isprime(int& x){
for(int i = 2 ; i * i <= x ; i++ ) if( x % i == 0) return true;
return false;
}
int solve(int i){
while(true){ if(dp[i] && !isprime(i)) return i; i--; }
}
int main(){
int n,x,data[30],ans;
while(cin >> n >> x , n){
fill_n(dp,1000001,false); dp[0] = true;
for(int i = 0 ; i < n ; i++ ) cin >> data[i];
for(int i = 0 ; i <= x ; i++ ){
if(dp[i]) for(int j = 0 ; j < n ; j++ )
if(i + data[j] <= x) dp[i+data[j]] = true;
}
if(1 < (ans = solve(x))) cout << ans << endl;
else cout << "NA" << endl;
}
} | #include<iostream>
#include<algorithm>
using namespace std;
bool dp[1000001];
bool isprime(int& x){
for(int i = 2 ; i * i <= x ; i++ ) if( x % i == 0) return true;
return x == 1;
}
int solve(int i){
while(true){
if(dp[i] && !isprime(i)) return i;
i--;
}
}
int main(){
int n,x,data,ans;
dp[0] = true;
while(cin >> n >> x , n){
for(int i = 1 ; i <= x ; i++ ) dp[i] = false;
for(int i = 0 ; i < n ; i++ ){
cin >> data;
for(int i = data ; i <= x ; i++ ) if(dp[i-data]) dp[i] = true;
}
if(ans = solve(x)) cout << ans << endl;
else cout << "NA" << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
病院の部屋番号
=======
ウォーターデブンに住む建築家のデブンキーさんのもとに、古い大病院を改装する仕事の依頼が舞い込んできました。
国によっては忌み数(いみかず)として嫌われる数字を部屋番号に用いたくない人がいます(日本では 4 と 9 が有名です)。しかし、この病院の部屋番号は忌み数に関係なく、1 から順番に付けられていました。
それが気になったデブンキーさんは、機材やベッドの入れ替えが全て終わる前にウォーターデブンの忌み数である「4」と「6」を除いた数字で部屋番号を付けなおしてしまいました。しかし、入れ替え作業は旧部屋番号で計画していたので、残りの作業を確実に行うには旧部屋番号を新部屋番号に変換する必要があります。計算が苦手なデブンキーさんはこのことに気づいて愕然としています。
そんなデブンキーさんのために、旧部屋番号を入力とし対応する新部屋番号を出力するプログラムを作成してください。
15 番目までの部屋番号の対応表は以下のようになります。
| 旧部屋番号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 新部屋番号 | 1 | 2 | 3 | 5 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 15 | 17 | 18 | 19 |
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、旧部屋番号を表す整数 n (1 ≤ n ≤ 1,000,000,000) が１行に与えられます。
データセットの数は 30000 を超えません。
Output
------
入力データセットごとに、新部屋番号を１行に出力します。
Sample Input
------------
```
15
100
1000000000
3
0
```
Output for the Sample Input
---------------------------
```
19
155
9358757000
3
```
| #include<vector>
#include<list>
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
int i;
int a[]={0,1,2,3,5,7,8,9},n;
while(cin>>n&&n){
for(i=0;pow(8,i)<=n;i++);
for(i--;i>=0;i--){
cout<<a[n/(int)pow(8,i)];
n%=(int)pow(8,i);
}
cout<<endl;
}
return 0;
} | #include<cstdio>
int main(){
int i;
int a[11]={1},n;
char s[9]="01235789";
for(i=1;i<11;++i)
a[i]=a[i-1]*8;
while(scanf("%d",&n),n){
for(i=0;a[i]<=n;++i);
for(--i;i>=0;--i){
printf("%c",s[n/a[i]]);
n%=a[i];
}
puts("");
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
病院の部屋番号
=======
ウォーターデブンに住む建築家のデブンキーさんのもとに、古い大病院を改装する仕事の依頼が舞い込んできました。
国によっては忌み数(いみかず)として嫌われる数字を部屋番号に用いたくない人がいます(日本では 4 と 9 が有名です)。しかし、この病院の部屋番号は忌み数に関係なく、1 から順番に付けられていました。
それが気になったデブンキーさんは、機材やベッドの入れ替えが全て終わる前にウォーターデブンの忌み数である「4」と「6」を除いた数字で部屋番号を付けなおしてしまいました。しかし、入れ替え作業は旧部屋番号で計画していたので、残りの作業を確実に行うには旧部屋番号を新部屋番号に変換する必要があります。計算が苦手なデブンキーさんはこのことに気づいて愕然としています。
そんなデブンキーさんのために、旧部屋番号を入力とし対応する新部屋番号を出力するプログラムを作成してください。
15 番目までの部屋番号の対応表は以下のようになります。
| 旧部屋番号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 新部屋番号 | 1 | 2 | 3 | 5 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 15 | 17 | 18 | 19 |
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、旧部屋番号を表す整数 n (1 ≤ n ≤ 1,000,000,000) が１行に与えられます。
データセットの数は 30000 を超えません。
Output
------
入力データセットごとに、新部屋番号を１行に出力します。
Sample Input
------------
```
15
100
1000000000
3
0
```
Output for the Sample Input
---------------------------
```
19
155
9358757000
3
```
| #include <iostream>
#include <vector>
#include <algorithm>
void ToOctalNumber(int n){
if(!n)return;
ToOctalNumber(n >> 3);
std::cout << ((n&7)<4?n&7:(n&7)==4?5:(n&7)+2);
}
int main(){
int n;
while(std::cin >> n, n){
ToOctalNumber(n);
std::cout << "\n";
}
} | #include <cstdio>
void ToOctalNumber(int n){
if(n){
ToOctalNumber(n >> 3);
printf("%d",(n&7)<4?n&7:(n&7)==4?5:(n&7)+2);
}
}
int main(){
int n;
while(scanf("%d",&n),n){
ToOctalNumber(n);
puts("");
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
病院の部屋番号
=======
ウォーターデブンに住む建築家のデブンキーさんのもとに、古い大病院を改装する仕事の依頼が舞い込んできました。
国によっては忌み数(いみかず)として嫌われる数字を部屋番号に用いたくない人がいます(日本では 4 と 9 が有名です)。しかし、この病院の部屋番号は忌み数に関係なく、1 から順番に付けられていました。
それが気になったデブンキーさんは、機材やベッドの入れ替えが全て終わる前にウォーターデブンの忌み数である「4」と「6」を除いた数字で部屋番号を付けなおしてしまいました。しかし、入れ替え作業は旧部屋番号で計画していたので、残りの作業を確実に行うには旧部屋番号を新部屋番号に変換する必要があります。計算が苦手なデブンキーさんはこのことに気づいて愕然としています。
そんなデブンキーさんのために、旧部屋番号を入力とし対応する新部屋番号を出力するプログラムを作成してください。
15 番目までの部屋番号の対応表は以下のようになります。
| 旧部屋番号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 新部屋番号 | 1 | 2 | 3 | 5 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 15 | 17 | 18 | 19 |
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、旧部屋番号を表す整数 n (1 ≤ n ≤ 1,000,000,000) が１行に与えられます。
データセットの数は 30000 を超えません。
Output
------
入力データセットごとに、新部屋番号を１行に出力します。
Sample Input
------------
```
15
100
1000000000
3
0
```
Output for the Sample Input
---------------------------
```
19
155
9358757000
3
```
| #include <iostream>
using namespace std;
const int t[8] = { 0, 1, 2, 3, 5, 7, 8, 9 };
/*void solve(int n){
if(n >= 8)
solve(n / 8);
cout << table[n % 8] ;
}*/
long long int solve(int n){
long long int s=0;
for(int i=1 ; n >0; i *= 10 , n /= 8)
s += (long long int)t[n%8]*i;
return s;
}
int main(){
int n;
while( cin >> n , n ){
cout << solve(n) << endl;
}
} | #import<cstdio>
int t[]={0,1,2,3,5,7,8,9};
void s(int n){if(n>7)s(n/8);printf("%d",t[n%8]);}
main(){for(int a;scanf("%d",&a),a;puts(""))s(a);} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
病院の部屋番号
=======
ウォーターデブンに住む建築家のデブンキーさんのもとに、古い大病院を改装する仕事の依頼が舞い込んできました。
国によっては忌み数(いみかず)として嫌われる数字を部屋番号に用いたくない人がいます(日本では 4 と 9 が有名です)。しかし、この病院の部屋番号は忌み数に関係なく、1 から順番に付けられていました。
それが気になったデブンキーさんは、機材やベッドの入れ替えが全て終わる前にウォーターデブンの忌み数である「4」と「6」を除いた数字で部屋番号を付けなおしてしまいました。しかし、入れ替え作業は旧部屋番号で計画していたので、残りの作業を確実に行うには旧部屋番号を新部屋番号に変換する必要があります。計算が苦手なデブンキーさんはこのことに気づいて愕然としています。
そんなデブンキーさんのために、旧部屋番号を入力とし対応する新部屋番号を出力するプログラムを作成してください。
15 番目までの部屋番号の対応表は以下のようになります。
| 旧部屋番号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 新部屋番号 | 1 | 2 | 3 | 5 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 15 | 17 | 18 | 19 |
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットとして、旧部屋番号を表す整数 n (1 ≤ n ≤ 1,000,000,000) が１行に与えられます。
データセットの数は 30000 を超えません。
Output
------
入力データセットごとに、新部屋番号を１行に出力します。
Sample Input
------------
```
15
100
1000000000
3
0
```
Output for the Sample Input
---------------------------
```
19
155
9358757000
3
```
| #include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <iostream>
#include <sstream>
#include <climits>
#include <cfloat>
#include <complex>
using namespace std;
typedef long long ll;
ll count_rooms_lesseq_than(ll newRoomNo)
{
int t[10], d;
for (d = 0; newRoomNo; ++d, newRoomNo /= 10)
t[d] = newRoomNo % 10;
for (int i = d-1; i > 0; --i)
{
if (t[i] == 4 || t[i] == 6)
{
--t[i];
for (int j = 0; j < i; ++j)
t[j] = 9;
break;
}
}
ll res = 0;
for (int i = 0; i < d; ++i)
{
ll a = 1;
for (int j = 0; j < i; ++j)
a *= 8;
res += (t[i] - (t[i] >= 6 ? 2 : t[i] >= 4 ? 1 : 0)) * a;
}
return res;
}
int main()
{
int n;
while (scanf("%d", &n), n)
{
ll l, u;
l = 1;
u = n * 10LL;
while (l < u)
{
ll m = (l + u) / 2;
ll t = count_rooms_lesseq_than(m);
if (t < n)
l = m + 1;
else
u = m;
}
printf("%lld\n", l);
}
return 0;
} | #include <cstdio>
int main()
{
int n;
while (scanf("%d", &n), n)
{
int t[10], d;
for (d = 0; n; ++d, n /= 8)
t[d] = n % 8;
for (int i = d-1; i >= 0; --i)
printf("%d", t[i] >= 5 ? t[i]+2 : t[i] == 4 ? t[i]+1 : t[i]);
printf("\n");
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
みんなでジョギング
=========
赤ベコ小学校では、生徒全員が参加する、ちょっと変わったジョギングをします。生徒は、それぞれ独自の周回コースを、自分のペースで走ります。それぞれ自分のコースを 1 周すると小学校に戻ってきます。全員が小学校を同時にスタートしてから、全員が同時に小学校で最初に出会うのは、それぞれ何周したときでしょうか?
生徒の人数 n、各生徒のコースの 1 周の距離 d (km) 、各生徒の走る速さ v (km/時間)を入力とし、全員が小学校を同時にスタートしてから次に同時に小学校に位置するのは、各生徒がそれぞれ何周したときかを出力するプログラムを作成してください。なお、各生徒は 231-1 周を超えて走ることはありません。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
d1 v1
d2 v2
:
dn vn
```
1 行目に生徒の人数 n (2 ≤ n ≤ 10) が与えられます。続く n 行に i 人目の生徒のコースの１周の距離 di (1 ≤ di ≤ 10000) と走る速さ vi (1 ≤ vi ≤ 10000) が与えられます。
データセットの数は 2000 を超えません。
Output
------
入力データセットごとに、各生徒の周回数を出力します。各生徒の周回数は入力の順番に従ってそれぞれ１行に出力してください。
Sample Input
------------
```
2
4 3
5 4
5
789 289
166 46
9 4
617 252
972 303
2
8 5
32 20
0
```
Output for the Sample Input
---------------------------
```
15
16
1598397732
1209243492
1939462992
1782294192
1360317793
1
1
```
| #include<iostream>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b){
return (!b)?a:gcd(b,a%b);
}
int main(){
int n;
ll d[10],v[10],t[10];
for(;;){
cin >> n;
if(!n)break;
for(int i=0;i<n;i++)cin >> d[i] >> v[i];
t[0] = 1;
for(int i=1;i<n;i++){
t[i] = t[i-1]*d[i-1]*v[i];
for(int j=0;j<i;j++)t[j] *= d[i]*v[i-1];
ll T = t[0];
for(int j=1;j<=i;j++)T = gcd(T,t[j]);
for(int j=0;j<=i;j++)t[j]/=T;
}
for(int i=0;i<n;i++)cout << t[i] << endl;
}
} | #include<cstdio>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b){return (!b)?a:gcd(b,a%b);}
int main(){
int n,i,j;
ll d[10],v[10],t[10];
for(;;){
scanf("%d",&n);
if(!n)break;
for(i=0;i<n;i++)scanf("%lld %lld",&d[i],&v[i]);
t[0] = 1;
for(i=1;i<n;i++){
t[i] = t[i-1]*d[i-1]*v[i];
for(j=0;j<i;j++)t[j] *= d[i]*v[i-1];
ll T = t[0];
for(j=1;j<=i;j++)T = gcd(T,t[j]);
for(j=0;j<=i;j++)t[j]/=T;
}
for(i=0;i<n;i++)printf("%lld\n",t[i]);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
みんなでジョギング
=========
赤ベコ小学校では、生徒全員が参加する、ちょっと変わったジョギングをします。生徒は、それぞれ独自の周回コースを、自分のペースで走ります。それぞれ自分のコースを 1 周すると小学校に戻ってきます。全員が小学校を同時にスタートしてから、全員が同時に小学校で最初に出会うのは、それぞれ何周したときでしょうか?
生徒の人数 n、各生徒のコースの 1 周の距離 d (km) 、各生徒の走る速さ v (km/時間)を入力とし、全員が小学校を同時にスタートしてから次に同時に小学校に位置するのは、各生徒がそれぞれ何周したときかを出力するプログラムを作成してください。なお、各生徒は 231-1 周を超えて走ることはありません。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
d1 v1
d2 v2
:
dn vn
```
1 行目に生徒の人数 n (2 ≤ n ≤ 10) が与えられます。続く n 行に i 人目の生徒のコースの１周の距離 di (1 ≤ di ≤ 10000) と走る速さ vi (1 ≤ vi ≤ 10000) が与えられます。
データセットの数は 2000 を超えません。
Output
------
入力データセットごとに、各生徒の周回数を出力します。各生徒の周回数は入力の順番に従ってそれぞれ１行に出力してください。
Sample Input
------------
```
2
4 3
5 4
5
789 289
166 46
9 4
617 252
972 303
2
8 5
32 20
0
```
Output for the Sample Input
---------------------------
```
15
16
1598397732
1209243492
1939462992
1782294192
1360317793
1
1
```
| #include <iostream>
#include <algorithm>
using namespace std;
long long d[10],v[10];
void compute(int n){
for(int i = 2 ; i <= min(d[n],v[n]) ; i++){
if(d[n]%i==0||v[n]%i==0){
while(d[n]%i==0&&v[n]%i==0){
d[n] /= i;
v[n] /= i;
}
}
}
}
int main(){
int n;
while(cin >>n,n){
long long a,b;
for(int i = 0 ; i < n ; i++){
cin >> d[i] >> v[i];
compute(i);
}
a = (d[0]*d[1])/__gcd(d[0],d[1]);
b = __gcd(v[0],v[1]);
for(int i = 2 ; i < n ; i++){
a = (a*d[i])/__gcd(a,d[i]);
b = __gcd(b,v[i]);
}
for(int i = 0 ; i < n ; i++){
cout << a*v[i]/(b*d[i]) << endl;
}
}
return 0;
} | #include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
#define MAX 10
typedef long long ll;
ll d[MAX],v[MAX];
ll gcd(ll a,ll b){
return __gcd(a,b);
}
ll lcm(ll a,ll b){
return a * b / gcd(a,b);
}
int main(){
int n;
while(scanf("%d" ,&n) ,n){
for(int i = 0 ; i < n ; i++){
scanf("%lld %lld" ,&d[i] ,&v[i]);
ll a = gcd(d[i],v[i]);
d[i] /= a;
v[i] /= a;
}
ll T = d[0],V = v[0];
for(int i = 1 ; i < n ; i++){
T = lcm(T,d[i]);
V = gcd(V,v[i]);
}
for(int i = 0 ; i < n ; i++){
ll div = T / d[i];
printf("%lld\n" ,div*v[i]/V);
}
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
パチモンクリーチャー
==========
某国で大人気のゲーム、パチモンクリーチャーが日本でリメイクされて発売されました。 ゲームが大好きなあなたは、 このゲームを何度もプレイするうちにどうしたら最速でクリアできるのか考えるようになりました。しかし、いくら考えても最速の攻略方法がわからなかったあなたは、どれだけ早くゲームをクリアできるかを求めるプログラムを作成することにしました。
ゲームの詳細は以下の通りです。
パチモンクリーチャー(以下、パチクリ)という生物が多く存在する世界がゲームの舞台です。各パチクリは、火属性、氷属性、木属性、土属性、水属性の 5 種類の属性のいずれか１つの属性を持ちます。ゲームの主人公は、ゲーム開始時に好きな属性のパチクリ一匹を冒険のパートナーとして選びます。そのパチクリと共にゴールを目指し、ゴールにいるライバルを倒してパチクリマスターになることがゲームの目的です。
しかし、ライバルを倒すためには全属性のパチクリがいないと勝てないので、途中で全属性のパチクリを捕まえなければなりません。パチクリを捕まえるには属性がカギとなります。火属性のパチクリは氷属性のパチクリを捕まえることができ、同様に、氷属性は木属性、木属性は土属性、土属性は水属性、水属性は火属性を捕まえることができます。属性の関連は以下の図のようになります。
以下の図はゲームが行われるマップの一例を表しています。
主人公はパチクリを一匹もってスタート地点である「S」から出発し、一マスずつ移動しながらゴール地点である「G」を目指します。その途中で、最初に持っているパチクリ以外の 4 つの属性のパチクリを捕まえ、ゴール地点であるマス目に移動するとゲーム終了となります。
主人公は、今いるマス目から、辺を共有する隣のマス目に移動することができ、それを一回の移動と数えます。主人公がパチクリのいるマスに移動した場合、そのパチクリを捕まえられる属性のパチクリを持っていればそのパチクリを捕まえたことになります。そのマスにいるパチクリを捕まえられるかの可否にかかわらず、すべてのマスに何度でも移動することができます。
マップの大きさ(横方向の列数、縦方向の行数)とマップの初期状態を入力とし、初めに選んだパチクリの属性と、それ以外の 4 つの属性のパチクリを捕まえるのにかかる、スタート地点からゴール地点に至る最小移動数を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終りはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
W H
c11c12...c1W
c21c22...c2W
:
cH1cH2...cHW
```
1 行目にマップの横方向の列数 W と縦方向の行数 H (2 ≤ W, H ≤ 1000) が与えられます。続く H 行にマップの i 行目の情報が与えられます。入力されるマップには各マスの状態が与えられます。 「S」は主人公のスタート地点を、 「G」はゴール地点を、「1」「2」「3」「4」「5」はそこにいるパチクリの属性を( 1:火属性、 2:氷属性、 3:木属性、 4:土属性、 5:水属性 をそれぞれ表します)、 「.(ピリオド) 」は何もないマスをそれぞれ表します。
各属性のパチクリの数はそれぞれ 0 以上 1000 以下とします。
データセットの数は140 を超えません。また、データセットの 80 % について、W, H は100 を超えません。
Output
------
入力データセットごとに、最初に選んだパチクリの属性と最小移動数を１行に出力します。なお、どのように初めのパチクリを選んでも、どのような経路で移動してもそれら 4 つの属性のパチクリを捕まえることができない場合は NA と出力してください。 また、最小移動数が同じになるような最初のパチクリの選び方が複数ある場合は、属性の数字が小さいものを出力してください。
Sample Input
------------
```
6 6
S.1..4
3..5..
..4.1.
4....5
.2.32.
5.1..G
3 2
...
S.G
0 0
```
Output for the Sample Input
---------------------------
```
2 10
NA
```
| #include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
#include<queue>
#define INF 99999999
using namespace std;
typedef pair<int, int> P;
vector<P> point[7];
int x,y;
int dp[6][1001][6];
char mas[1001][1001];
int cx[6],ans;
int sp,ans1;
int solve(int i , int j, int z);
int main(){
while(1){
for(int i = 0; i < 7; i++){
point[i].clear();
}
memset(cx, 0, sizeof(cx));
ans1 = INF;
sp = INF;
cin >> x >> y;
if(x == 0 && y == 0) break;
for(int i = 0; i < y; i++) cin >> mas[i];
for(int i = 0; i < y; i++){
for(int j = 0; j < x; j++){
if(mas[i][j] == 'S'){
point[0].push_back(P(j,i));
}
if(mas[i][j] == 'G'){
point[6].push_back(P(j,i));
}
if(mas[i][j] >= '1' && mas[i][j] <= '5'){
point[mas[i][j] - '0'].push_back(P(j,i));
cx[mas[i][j] - '0']++;
}
}
}
for(int i = 1; i <= 5; i++){
rotate(point + 1, point + 2, point + 6);
rotate(cx + 1, cx + 2, cx + 6);
memset(dp, -1, sizeof(dp));
ans = solve(0, 0, 0);
if(ans < ans1){
ans1 = ans;
sp = i;
}
}
if(ans1 == INF) cout << "NA" << endl;
else cout << sp << " " << ans1 << endl;
}
}
int solve(int i, int j,int z){
if(dp[i][j][z] >= 0) return dp[i][j][z];
if(i == 4){
return abs(point[6][0].first - point[z][j].first) + abs(point[6][0].second - point[z][j].second);
}
int res = INF;
for(int k = 0; k < cx[z + 1]; k++){
res = min(abs(point[z + 1][k].first - point[z][j].first) + abs(point[z + 1][k].second - point[z][j].second) + solve(i + 1, k, z + 1),res);
}
return dp[i][j][z] = res;
} | #include<algorithm>
#include<cstring>
#include<cstdio>
#define INF 1<<28
using namespace std;
int sx, sy, gx, gy;
int dx[5][1111], dy[5][1111], dn[5];
int memo[5][5][1111];
int a, b;
int solve(int k, int t, int q){
if(k == 4) return abs(dx[t][q]-gx) + abs(dy[t][q]-gy);
if(memo[k][t][q]) return memo[k][t][q];
int ans = INF, d = (t+1)%5, s;
for(int i=0;i<dn[d];i++){
if(!k) s = abs(sx-dx[d][i]) + abs(sy-dy[d][i]);
else s = abs(dx[t][q]-dx[d][i]) + abs(dy[t][q]-dy[d][i]);
ans = min(ans, solve(k+1, d, i) + s);
}
return memo[k][t][q] = ans;
}
int main(){
int w,h;
char c;
while(true){
scanf("%d %d", &w, &h);
if(!w && !h) break;
memset(dn, 0, sizeof(dn));
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
scanf(" %c", &c);
if(c == 'S') sx = j, sy = i;
else if(c == 'G') gx = j, gy = i;
else if(c != '.') dx[c-'1'][dn[c-'1']] = j, dy[c-'1'][dn[c-'1']] = i, dn[c-'1']++;
}
}
b = INF;
for(int i=0;i<5;i++){
memset(memo, 0, sizeof(memo));
if(b > solve(0,i,0)) a = i, b = solve(0,i,0);
}
if(b == INF) printf("NA\n");
else printf("%d %d\n", a+1, b);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
パチモンクリーチャー
==========
某国で大人気のゲーム、パチモンクリーチャーが日本でリメイクされて発売されました。 ゲームが大好きなあなたは、 このゲームを何度もプレイするうちにどうしたら最速でクリアできるのか考えるようになりました。しかし、いくら考えても最速の攻略方法がわからなかったあなたは、どれだけ早くゲームをクリアできるかを求めるプログラムを作成することにしました。
ゲームの詳細は以下の通りです。
パチモンクリーチャー(以下、パチクリ)という生物が多く存在する世界がゲームの舞台です。各パチクリは、火属性、氷属性、木属性、土属性、水属性の 5 種類の属性のいずれか１つの属性を持ちます。ゲームの主人公は、ゲーム開始時に好きな属性のパチクリ一匹を冒険のパートナーとして選びます。そのパチクリと共にゴールを目指し、ゴールにいるライバルを倒してパチクリマスターになることがゲームの目的です。
しかし、ライバルを倒すためには全属性のパチクリがいないと勝てないので、途中で全属性のパチクリを捕まえなければなりません。パチクリを捕まえるには属性がカギとなります。火属性のパチクリは氷属性のパチクリを捕まえることができ、同様に、氷属性は木属性、木属性は土属性、土属性は水属性、水属性は火属性を捕まえることができます。属性の関連は以下の図のようになります。
以下の図はゲームが行われるマップの一例を表しています。
主人公はパチクリを一匹もってスタート地点である「S」から出発し、一マスずつ移動しながらゴール地点である「G」を目指します。その途中で、最初に持っているパチクリ以外の 4 つの属性のパチクリを捕まえ、ゴール地点であるマス目に移動するとゲーム終了となります。
主人公は、今いるマス目から、辺を共有する隣のマス目に移動することができ、それを一回の移動と数えます。主人公がパチクリのいるマスに移動した場合、そのパチクリを捕まえられる属性のパチクリを持っていればそのパチクリを捕まえたことになります。そのマスにいるパチクリを捕まえられるかの可否にかかわらず、すべてのマスに何度でも移動することができます。
マップの大きさ(横方向の列数、縦方向の行数)とマップの初期状態を入力とし、初めに選んだパチクリの属性と、それ以外の 4 つの属性のパチクリを捕まえるのにかかる、スタート地点からゴール地点に至る最小移動数を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終りはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
W H
c11c12...c1W
c21c22...c2W
:
cH1cH2...cHW
```
1 行目にマップの横方向の列数 W と縦方向の行数 H (2 ≤ W, H ≤ 1000) が与えられます。続く H 行にマップの i 行目の情報が与えられます。入力されるマップには各マスの状態が与えられます。 「S」は主人公のスタート地点を、 「G」はゴール地点を、「1」「2」「3」「4」「5」はそこにいるパチクリの属性を( 1:火属性、 2:氷属性、 3:木属性、 4:土属性、 5:水属性 をそれぞれ表します)、 「.(ピリオド) 」は何もないマスをそれぞれ表します。
各属性のパチクリの数はそれぞれ 0 以上 1000 以下とします。
データセットの数は140 を超えません。また、データセットの 80 % について、W, H は100 を超えません。
Output
------
入力データセットごとに、最初に選んだパチクリの属性と最小移動数を１行に出力します。なお、どのように初めのパチクリを選んでも、どのような経路で移動してもそれら 4 つの属性のパチクリを捕まえることができない場合は NA と出力してください。 また、最小移動数が同じになるような最初のパチクリの選び方が複数ある場合は、属性の数字が小さいものを出力してください。
Sample Input
------------
```
6 6
S.1..4
3..5..
..4.1.
4....5
.2.32.
5.1..G
3 2
...
S.G
0 0
```
Output for the Sample Input
---------------------------
```
2 10
NA
```
| #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define rep(i,n) for(int i = 0 ; i < n ; i++)
struct P{int x,y;P(){}P(int a,int b){x = a , y = b;}};
int operator -(P a, P b){
return abs(a.x - b.x) + abs(a.y - b.y);
}
int dp[1<<5][5][1000];
#define INF (1<<21)
int main(){
int W,H;
while(cin >> W >> H , W){
P s , g ;
vector<P> v[6];
rep(i,H)rep(j,W){
char c; cin >> c;
if(c == 'S') s = P(j,i);
else if(c == 'G') g = P(j,i);
else if(c != '.') v[c-'1'].push_back(P(j,i));
}
rep(i,1<<5)rep(k,5)rep(j,1000)dp[i][k][j] = INF;
rep(i,5)rep(j,v[(i+1)%5].size()){
dp[(1<<i) | (1<<((i+1)%5))][(i+1)%5][j] = s - v[(i+1)%5][j];
}
rep(bit,(1<<5)-1)rep(x,5){
int y = (x+1)%5;
rep(i,v[x].size()){
if( dp[bit][x][i] == INF ) break; // <- ツ催適ツ可サ
rep(j,v[y].size()){
dp[bit|(1<<y)][y][j] = min( dp[bit|(1<<y)][y][j] , dp[bit][x][i] + (v[x][i]-v[y][j]) );
}
}
}
int ans = INF , cho = -1;
rep(i,5) rep( j , v[i].size() ){
int cst = dp[(1<<5)-1][i][j] + (g - v[i][j]);
int w = (i+1)%5;
if(ans >= cst){
if(ans == cst){
cho = min(cho, w );
}else{
cho = w;
ans = cst;
}
}
}
if(ans == INF) cout << "NA" << endl;
else cout << cho+1 << " " << ans << endl;
}
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <cstring>
#include <cstdio>
#define rep(i,n) for(int i = 0 ; i < n ; i++)
using namespace std;
int W,H;
int sx,sy,gx,gy;
vector< pair<int,int> > e[5];
int memo[1000][1000][5] = {};
int dfs(int x,int y,int c,int r){
if( memo[x][y][c] != -1 ) return memo[x][y][c];
if( r == 0 ) return abs(gx-x)+abs(gy-y);
int g = (c+1)%5;
int ans = 1e8;
for(int i = 0 ; i < e[g].size() ; i++){
ans = min( ans , dfs(e[g][i].first,e[g][i].second,g,r-1) + abs(e[g][i].first-x)+abs(e[g][i].second-y) );
}
return memo[x][y][c] = ans;
}
int main(){
ios_base::sync_with_stdio(false);
while(cin >> W >> H && W){
rep(i,5)e[i].clear();
sx = sy = gx = gy = 1e7;
vector< pair<int,int> > list;
rep(i,H){
rep(j,W){
char c;
cin >> c;
if( c == 'S' ) sx = j , sy = i;
else if( c == 'G' ) gx = j , gy = i;
else if( c != '.' ) e[c-'1'].push_back(make_pair(j,i)), list.push_back(make_pair(j,i));
}
}
list.push_back(make_pair(sx,sy));
list.push_back(make_pair(gx,gy));
int F = !e[0].size() + !e[1].size() + !e[2].size() + !e[3].size() + !e[4].size();
if( F >= 2){
cout << "NA" << endl;
continue;
}
pair<int,int> ans = make_pair(1e8,1e8);
rep(i,5){
rep(j,list.size()) rep(k,5) memo[list[j].first][list[j].second][k] = -1;
ans = min(ans,make_pair(dfs(sx,sy,i,4),i));
}
if( 1e6 > ans.first ){
cout << ans.second+1 << " " << ans.first << endl;
}else{
cout << "NA" << endl;
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ウォーキング
======
会津リバーサイドホスピタルでは、リハビリと健康増進のため、入院患者が一日二回のウォーキングを行っています。元気に退院するために、ウォーキングで体力を回復しようと頑張る人が日に日に増えきたことから、院長が「一日で一番長い距離を歩いた人にプレゼントをあげよう!」という企画を立ち上げました。
患者の数 n (1 ≤ n ≤ 10000)、それぞれの患者の番号 pi (1 ≤ pi ≤ 10000)、一回目に歩いた距離 d1i、二回目に歩いた距離 d2i (0 ≤ d1i, d2i ≤ 5000) を入力とし、歩いた距離の合計が最も長い患者の番号とその距離を出力するプログラムを作成してください。ただし、一日に歩いた距離が同じ患者はいないものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
p1 d11 d21
p2 d12 d22
:
pn d1n d2n
```
入力はすべて整数で与えられます。データセットの数は50 を超えません。
Output
------
入力データセットごとに、最も長い合計距離を歩いた患者の番号とその歩いた距離を１行に出力します。
Sample Input
------------
```
5
263 2345 2504
1 3210 1985
5000 1501 4132
10000 503 3107
51 1758 2690
3
345 5000 2396
7 3910 1590
6789 2525 3616
0
```
Output for the Sample Input
---------------------------
```
5000 5633
345 7396
```
| #include <iostream>
#include <vector>
using namespace std;
typedef struct P {
int p, d;
bool operator<(const P &r) {
return d < r.d;
}
} P;
int n, d[10001];
vector<P> v;
int main(){
int p, d1, d2;
while (cin >> n && n != 0) {
v = vector<P>();
for (int i = 0; i < n; i++) {
cin >> p >> d1 >> d2;
v.push_back({ p,d1 + d2 });
}
P m = v[0];
for (int i = 1; i < v.size(); i++) {
if (m < v[i]) {
m = v[i];
}
}
cout << m.p << " " << m.d << endl;
}
return 0;
} | #include <cstdio>
#include <vector>
using namespace std;
typedef struct P {
int p, d;
bool operator<(const P &r) {
return d < r.d;
}
} P;
int n;;
int main(){
int p, d1, d2;
while (true) {
scanf("%d", &n);
if (n == 0) break;
P m = { 0,-1 };
P t;
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &p, &d1, &d2);
t = { p,d1 + d2 };
if (m < t) {
m = t;
}
}
printf("%d %d\n", m.p, m.d);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ウォーキング
======
会津リバーサイドホスピタルでは、リハビリと健康増進のため、入院患者が一日二回のウォーキングを行っています。元気に退院するために、ウォーキングで体力を回復しようと頑張る人が日に日に増えきたことから、院長が「一日で一番長い距離を歩いた人にプレゼントをあげよう!」という企画を立ち上げました。
患者の数 n (1 ≤ n ≤ 10000)、それぞれの患者の番号 pi (1 ≤ pi ≤ 10000)、一回目に歩いた距離 d1i、二回目に歩いた距離 d2i (0 ≤ d1i, d2i ≤ 5000) を入力とし、歩いた距離の合計が最も長い患者の番号とその距離を出力するプログラムを作成してください。ただし、一日に歩いた距離が同じ患者はいないものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
p1 d11 d21
p2 d12 d22
:
pn d1n d2n
```
入力はすべて整数で与えられます。データセットの数は50 を超えません。
Output
------
入力データセットごとに、最も長い合計距離を歩いた患者の番号とその歩いた距離を１行に出力します。
Sample Input
------------
```
5
263 2345 2504
1 3210 1985
5000 1501 4132
10000 503 3107
51 1758 2690
3
345 5000 2396
7 3910 1590
6789 2525 3616
0
```
Output for the Sample Input
---------------------------
```
5000 5633
345 7396
```
| #include <iostream>
using namespace std;
#define MAX 10000
int main(void){
int n,data[MAX+1],des[2],num,max,mnum;
for(;;){
max = mnum = 0;
for( int i = 0 ; i <= MAX ; i++ )
data[i] = 0;
cin >> n;
if( n == 0 ) break;
for( int i = 0 ; i < n ; i++ ){
cin >> num >> des[1] >> des[0];
data[num] = des[0] + des[1];
if( data[num] > max ){
max = data[num];
mnum = num;
}
}
cout << mnum << " " << max << endl;
}
return 0;
} | #include <cstdio>
int main(){
int n;
while(scanf("%d" ,&n) ,n){
int p,d1,d2;
int ans = 0,num;
while(n--){
scanf("%d %d %d" ,&p ,&d1 ,&d2);
if(ans < d1+d2){
ans = d1+d2;
num = p;
}
}
printf("%d %d\n" ,num ,ans);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ウォーキング
======
会津リバーサイドホスピタルでは、リハビリと健康増進のため、入院患者が一日二回のウォーキングを行っています。元気に退院するために、ウォーキングで体力を回復しようと頑張る人が日に日に増えきたことから、院長が「一日で一番長い距離を歩いた人にプレゼントをあげよう!」という企画を立ち上げました。
患者の数 n (1 ≤ n ≤ 10000)、それぞれの患者の番号 pi (1 ≤ pi ≤ 10000)、一回目に歩いた距離 d1i、二回目に歩いた距離 d2i (0 ≤ d1i, d2i ≤ 5000) を入力とし、歩いた距離の合計が最も長い患者の番号とその距離を出力するプログラムを作成してください。ただし、一日に歩いた距離が同じ患者はいないものとします。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
p1 d11 d21
p2 d12 d22
:
pn d1n d2n
```
入力はすべて整数で与えられます。データセットの数は50 を超えません。
Output
------
入力データセットごとに、最も長い合計距離を歩いた患者の番号とその歩いた距離を１行に出力します。
Sample Input
------------
```
5
263 2345 2504
1 3210 1985
5000 1501 4132
10000 503 3107
51 1758 2690
3
345 5000 2396
7 3910 1590
6789 2525 3616
0
```
Output for the Sample Input
---------------------------
```
5000 5633
345 7396
```
| #include <iostream>
int main(){
int n;
while(std::cin >> n, n){
int max_p, max_d = 0;
for(;n;n--){
int p, d1, d2;
std::cin >> p >> d1 >> d2;
if(d1 + d2 > max_d)
max_p = p, max_d = d1 + d2;
}
std::cout << max_p << " " << max_d << std::endl;
}
} | #include <cstdio>
main(){int n;while(scanf("%d", &n), n){int t, m = 0, p, a, b;for(;n;n--){scanf("%d%d%d",&p,&a,&b);if(a+b>m)t=p,m=a+b;}printf("%d %d\n",t,m);}} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ヒストグラム
======
テンアイスクリームという名前のアイスクリーム屋さんがあります。このお店では常に 10 種類のアイスクリームが店頭に並ぶようにしています。お店の店長は商品開発の参考にするために、アイスクリームの売れ具合を表すグラフを毎日作成しています。
そんな店長のために、あなたは各アイスクリームの販売数をグラフで表示するプログラムを作成することになりました。
一日に販売されるアイスクリームの総数と売れたアイスクリームの番号を入力とし、アイスクリームの種類ごとに販売した数だけ \* (半角アスタリスク) を出力するプログラムを作成してください。ただし、アイスクリームの種類を 0 から 9 までの整数で表わします。また、販売個数がゼロのアイスクリームは、- (半角ハイフン) をひとつ出力します。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
c1
c2
:
cn
```
1 行目に一日に販売されるアイスクリームの総数 n (1 ≤ n ≤ 10000) が与えられます。続く n 行に第 i のアイスクリームの種類 ci (0 ≤ ci≤ 9) が与えられます。
データセットの数は 20 を超えません。
Output
------
入力データセットごとに、各アイスクリームの種類の番号順に販売数を出力します。
Sample Input
------------
```
15
2
6
7
0
1
9
8
7
3
8
9
4
8
2
2
3
9
1
5
0
```
Output for the Sample Input
---------------------------
```
*
*
***
*
*
-
*
**
***
**
-
*
-
-
-
*
-
-
-
*
```
| #include<iostream>
using namespace std;
int main()
{
int s[10] = {0}, i, a, n,j;
while (1) {
cin >> n;
if (n == 0)
break;
for (i = 0; i < n; i++) {
cin >> a;
s[a]++;
}
for (i = 0; i < 10; i++) {
if (s[i] == 0)
cout << "-";
else {
for (j = 0; j < s[i]; j++) {
cout << "*";
}
}
cout << endl;
s[i] = 0;
}
}
return 0;
} | #include<stdio.h>
int main()
{
int a,s[10]={},b;
scanf("%d",&a);
while(a!=0){
for(int i=0;i<a;i++){
scanf("%d",&b);
s[b]++;
}
for(int i=0;i<10;i++){
for(int j=0;j<s[i];j++){
printf("*");
}
if(s[i]==0)
printf("-");
printf("\n");
}
for(int i=0;i<10;i++){
s[i]=0;
}
scanf("%d",&a);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ヒストグラム
======
テンアイスクリームという名前のアイスクリーム屋さんがあります。このお店では常に 10 種類のアイスクリームが店頭に並ぶようにしています。お店の店長は商品開発の参考にするために、アイスクリームの売れ具合を表すグラフを毎日作成しています。
そんな店長のために、あなたは各アイスクリームの販売数をグラフで表示するプログラムを作成することになりました。
一日に販売されるアイスクリームの総数と売れたアイスクリームの番号を入力とし、アイスクリームの種類ごとに販売した数だけ \* (半角アスタリスク) を出力するプログラムを作成してください。ただし、アイスクリームの種類を 0 から 9 までの整数で表わします。また、販売個数がゼロのアイスクリームは、- (半角ハイフン) をひとつ出力します。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
c1
c2
:
cn
```
1 行目に一日に販売されるアイスクリームの総数 n (1 ≤ n ≤ 10000) が与えられます。続く n 行に第 i のアイスクリームの種類 ci (0 ≤ ci≤ 9) が与えられます。
データセットの数は 20 を超えません。
Output
------
入力データセットごとに、各アイスクリームの種類の番号順に販売数を出力します。
Sample Input
------------
```
15
2
6
7
0
1
9
8
7
3
8
9
4
8
2
2
3
9
1
5
0
```
Output for the Sample Input
---------------------------
```
*
*
***
*
*
-
*
**
***
**
-
*
-
-
-
*
-
-
-
*
```
| #include <iostream>
using namespace std;
int main(){
int n;
while( cin >> n , n ){
int ice[10] = {};
for(int i=0 ; i<n ; ++i ){
int a;
cin >> a;
ice[a]++;
}
for(int i=0 ; i<10 ; ++i ){
for(int j=0 ; j<ice[i] ; ++j ){
cout << "*";
}
if(!ice[i]) cout << "-";
cout << endl;
}
}
} | #include<cstdio>
int main(){
int i,j;
for(int n;scanf("%d",&n),n;){
int p[10]={};
for(i=n;i;--i)
scanf("%d",&j),++p[j];
for(i=0;i<10;++i,puts("")){
for(j=0;j<p[i];++j)
printf("*");
if(!p[i])printf("-");
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
自転車でダイエット
=========
A さんは甘いものが大好きですが、最近は奥さんからダイエットするように言われています。ある日、A さんが自宅から市役所に出かけるとき、奥さんは自転車で行くことを勧めました。そこでA さんはしぶしぶ自転車に乗って出かけましたが、甘い物の好きな A さんは、途中にあるケーキ屋さんに立ち寄りケーキの食べ歩きをしようと思いつきました。
自転車をこげば走行距離に応じてカロリーが消費されますが、ケーキを食べればその分カロリーが摂取されます。正味の消費カロリーは、自転車をこいで消費したカロリーからケーキを食べて摂取したカロリーを引いた値になります。したがって、正味の消費カロリーが 0 より小さくなることもあります。
ケーキ屋さんでケーキを買ったら、 Aさんはその場でケーキを全部食べてしまいます。 Aさんがすべてのケーキ屋さんに立ち寄るとは限りませんが、ケーキ屋さんが存在する地点を通るときには、必ず立ち寄ってケーキを 1 つ買って食べるものとします。ただし、同じケーキ屋さんの前を何度も通るのはさすがに気がひけるので、各ケーキ屋さんに訪れられるのは 1 回だけとします。また、目的地の市役所をいったん通り過ぎてからケーキ屋さんに立ち寄り、その後で市役所に戻って用を済ませてもよいものとし、ケーキ屋さん以外は何度訪れても良いものとします。
A さんの自宅から市役所までの地図情報と、その途中にあるケーキ屋さんで食べられるケーキのカロリーの一覧、単位距離の走行による消費カロリーを入力とし、自宅を出発してから市役所に入るまでの正味の消費カロリーの最小値を出力するプログラムを作成してください。
地図には、A さんの自宅と市役所、ケーキ屋さんとランドマーク(目印)になる建物が書かれています。地図を表す入力データは、A さんの自宅、市役所、ケーキ屋さんとランドマークの各地点の間をつなぐ道があるとき、2 つの地点を表す記号とその間の距離からなる行を含みます。たとえば、5 番目のケーキ屋さんと 3 番目のランドマークの間の距離が 10 なら、入力データは以下のような行を含みます。
```
C5 L3 10
```
このようにケーキ屋さんには C、ランドマークには L を番号の前につけて表します。また、A さんの自宅は H、市役所は D で表します。入力データに 2 つの地点とその間の距離が与えられているなら、2 地点の間をどちら向きにも進めます。たとえば、上の例ではケーキ屋さんからランドマークへも、その逆向きへも進むことができます。また、自宅から市役所までは必ずたどり着けるものとします。それ以外に与えられる入力データは、ケーキ屋さんの数 m、ランドマークの数 n、単位距離あたりの消費カロリー k、 1 番目のケーキ屋さんから m 番目のケーキ屋さんまでのそれぞれで買えるケーキのカロリーを表す m 個のデータ、距離のデータの総数 d です。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりは四つの 0 の行で示されます。
各データセットは以下の形式で与えられます。
```
m n k d
c1 c2 ... cm
s1 t1 e1
s2 t2 e2
:
sd td ed
```
1 行目にケーキ屋さんの数 m (1 ≤ m ≤ 6)、 ランドマークの数 n (1 ≤ n ≤ 100) 、単位距離あたりの消費カロリー k (1 ≤ k ≤ 5)、距離のデータの総数 d (5 ≤ d ≤ 256) が与えられます。
2 行目に各ケーキ屋で買うケーキのカロリー ci (1 ≤ ci ≤ 100) が与えられます。
続く d 行に i 番目の 2 つの地点間の距離データ si, ti, ei (1 ≤ ei ≤ 20) が与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、全体の消費カロリーの最小値を１行に出力します。
Sample Input
------------
```
1 1 2 5
35
H L1 5
C1 D 6
C1 H 12
L1 D 10
C1 L1 20
2 1 4 6
100 70
H L1 5
C1 L1 12
C1 D 11
C2 L1 7
C2 D 15
L1 D 8
0 0 0 0
```
Output for the Sample Input
---------------------------
```
1
-2
```
| #include <bits/stdc++.h>
using namespace std;
#define MAX 1000
#define INF (1e9)
struct Edge{
int to,cost,c;
Edge(int to,int cost,int c) :
to(to),cost(cost),c(c) {}
};
int main(){
int M,D,N,K;
int d[MAX][1<<6];
while(cin >> M >> N >> K >> D, M){
vector<Edge> G[MAX];
vector<int> cake(M);
for(int i = 0 ; i < M ; i++){
cin >> cake[i];
}
int idx = 0,c;
string a,b;
map<string,int> mp;
for(int i = 0 ; i < D ; i++){
cin >> a >> b >> c;
if(!mp.count(a)) mp[a] = idx++;
if(!mp.count(b)) mp[b] = idx++;
if(a[0] == 'C'){
G[mp[b]].push_back(Edge(mp[a],c,a[1]-'1'));
}else{
G[mp[b]].push_back(Edge(mp[a],c,-1));
}
if(b[0] == 'C'){
G[mp[a]].push_back(Edge(mp[b],c,b[1]-'1'));
}else{
G[mp[a]].push_back(Edge(mp[b],c,-1));
}
}
int s = mp["H"],t = mp["D"];
for(int i = 0 ; i < MAX ; i++){
for(int j = 0 ; j < (1<<6) ; j++){
d[i][j] = INF;
}
}
d[s][0] = 0;
bool update = 1;
while(update){
update = 0;
for(int i = 0 ; i < (int)mp.size() ; i++){
for(int j = 0 ; j < (int)G[i].size() ; j++){
Edge e = G[i][j];
for(int S = (1<<6)-1 ; S >= 0 ; S--){
int ncost = d[i][S];
if(ncost == INF) continue;
ncost += e.cost*K;
if(e.c == -1){
if(ncost < d[e.to][S]){
d[e.to][S] = ncost;
update = 1;
}
}else{
if(S >> e.c & 1) continue;
if(ncost-cake[e.c] < d[e.to][S|(1<<e.c)]){
d[e.to][S|(1<<e.c)] = ncost-cake[e.c];
update = 1;
}
}
}
}
}
}
int res = INF;
for(int i = 0 ; i < (1<<6) ; i++){
res = min(res, d[t][i]);
}
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define MAX 514
#define INF (1e9)
struct Edge{
int to,cost,c;
Edge(int to,int cost,int c) :
to(to),cost(cost),c(c) {}
};
int main(){
int M,D,N,K;
int d[MAX][1<<6];
while(cin >> M >> N >> K >> D, M){
vector<Edge> G[MAX];
vector<int> cake(M);
for(int i = 0 ; i < M ; i++){
cin >> cake[i];
}
int idx = 0,c;
string a,b;
map<string,int> mp;
for(int i = 0 ; i < D ; i++){
cin >> a >> b >> c;
if(!mp.count(a)) mp[a] = idx++;
if(!mp.count(b)) mp[b] = idx++;
if(a[0] == 'C'){
G[mp[b]].push_back(Edge(mp[a],c,a[1]-'1'));
}else{
G[mp[b]].push_back(Edge(mp[a],c,-1));
}
if(b[0] == 'C'){
G[mp[a]].push_back(Edge(mp[b],c,b[1]-'1'));
}else{
G[mp[a]].push_back(Edge(mp[b],c,-1));
}
}
int s = mp["H"],t = mp["D"];
for(int i = 0 ; i < MAX ; i++){
for(int j = 0 ; j < (1<<6) ; j++){
d[i][j] = INF;
}
}
d[s][0] = 0;
bool update = 1;
while(update){
update = 0;
for(int i = 0 ; i < (int)mp.size() ; i++){
for(int j = 0 ; j < (int)G[i].size() ; j++){
Edge e = G[i][j];
for(int S = (1<<6)-1 ; S >= 0 ; S--){
int ncost = d[i][S];
if(ncost == INF) continue;
ncost += e.cost*K;
if(e.c == -1){
if(ncost < d[e.to][S]){
d[e.to][S] = ncost;
update = 1;
}
}else{
if(S >> e.c & 1) continue;
if(ncost-cake[e.c] < d[e.to][S|(1<<e.c)]){
d[e.to][S|(1<<e.c)] = ncost-cake[e.c];
update = 1;
}
}
}
}
}
}
int res = INF;
for(int i = 0 ; i < (1<<6) ; i++){
res = min(res, d[t][i]);
}
cout << res << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
こぶたぬきつねこ
========
A子さんの家に親戚のB男君がやってきました。彼は3歳で歌が大好きです。彼は幼稚園でならった「こぶたぬきつねこ」(山本直純作詞・作曲)という歌を一生懸命に歌っています。この歌では、4つのことば「こぶた」 「たぬき」 「きつね」「ねこ」が順にしりとりになっていて、さらに最後の音と最初の音が同じになっています。B男君は、A子さんに、同じようなしりとりが、B男君が言った単語から作れるか教えて欲しいと言われました。
そこで、A子さんを助けるために、与えられた単語から、その単語をすべて使って、順にしりとりをつくり、その上で、 第1 の単語の最初の文字と最終の単語の最後の文字が同じであるようにできるか否かを判定するプログラムを作成しましょう。
n 個の単語を入力とし、それらの単語の組からしりとりを作成できるか否かを判定し、可能な場合はOK と、不可能な場合は NG と出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
```
n
word1
word2
:
wordn
```
1 行目に単語の個数 n (2 ≤ n ≤ 10000) が与えられます。続く n 行に n 個の単語 wordi (32 文字以下の半角英小文字だけからなる文字列) が与えられます。
データセットの数は 50 を超えません。
Output
------
入力データセットごとに、判定結果を１行に出力します。
Sample Input
------------
```
5
apple
yellow
georgia
king
email
7
apple
yellow
georgia
king
email
wink
lucky
0
```
Output for the Sample Input
---------------------------
```
NG
OK
```
| #include<iostream>
using namespace std;
bool visit[26],g[26][26];
bool dfs(int v){
visit[v] = true;
bool f = false;
for(int i=0;i<26;i++)
if(g[v][i]){
f = true;
if(!visit[i])dfs(i);
}
return f;
}
int graph_num(void){
int res = 0;
for(int i=0;i<26;i++)
if(!visit[i] && dfs(i))res++;
return res;
}
int main(){
int i,n,pre[26],suf[26],h,t;
string s;
while(cin>>n && n){
for(i=0;i<26;i++){
visit[i] = false;
pre[i] = suf[i] = 0;
for(int j=0;j<26;j++)g[i][j] = false;
}
for(i=0;i<n;i++){
cin >> s;
h = s[0]-'a', t = s[(int)s.size()-1]-'a';
pre[h]++;
suf[t]++;
g[h][t] = g[t][h] = true;
}
if(graph_num() != 1)printf("NG\n");
else{
for(i=0;i<26;i++)if(pre[i] != suf[i])break;
if(i==26)printf("OK\n");
else printf("NG\n");
}
}
} | #include<cstdio>
#include<cstring>
using namespace std;
bool visit[26],g[26][26];
bool dfs(int v){
visit[v] = true;
bool f = false;
for(int i=0;i<26;i++)
if(g[v][i]){
f = true;
if(!visit[i])dfs(i);
}
return f;
}
int graph_num(void){
int res = 0;
for(int i=0;i<26;i++)
if(!visit[i] && dfs(i))res++;
return res;
}
int main(){
int i,n,pre[26],suf[26],h,t;
while(scanf("%d",&n) && n){
for(i=0;i<26;i++){
visit[i] = false;
pre[i] = suf[i] = 0;
for(int j=0;j<26;j++)g[i][j] = false;
}
for(i=0;i<n;i++){
char s[40];
scanf("%s",s);
int len = strlen(s);
h = s[0]-'a';
t = s[len-1]-'a';
pre[h]++;
suf[t]++;
g[h][t] = g[t][h] = true;
}
if(graph_num() != 1)printf("NG\n");
else{
for(i=0;i<26;i++)if(pre[i] != suf[i])break;
if(i==26)printf("OK\n");
else printf("NG\n");
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ヒットアンドブロー
=========
太郎君と花子さんはヒットアンドブローで遊ぶことにしました。ヒットアンドブローのルールは、以下の通りです。
* 出題者と回答者に分かれて行う。
* 出題者は、重複した数を含まない 4 桁の数字(正解)を決める。
* 回答者は、その 4 桁の数字(回答)を言い当てる。
* 回答に対して、出題者はヒットとブローの数でヒントを与える。
* 回答と正解を比べて、数と桁位置の両方が同じであることをヒットと呼び、数だけが同じで桁位置が異なることをブローと呼ぶ。たとえば、正解が 1234 で、回答が 1354 なら、出題者は「2 ヒット、1 ブロー」というヒントを与え、正解までこれを繰り返す。
* 出題者と回答者は交代してゲームを行い、より少ない回答で正解を言い当てた方を勝ちとする。
太郎君と花子さんは、ヒットの数とブローの数をその都度判断することが少し面倒に感じているようです。そんな二人のために、ヒットの数とブローの数が即座に分かるプログラムを作成してあげましょう。
正解 r と回答 a を入力とし、ヒットの数とブローの数を出力するプログラムを作成してください。r、a はそれぞれ 0 から 9 の数字 4 つからなる数字の列です。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットとして、r と a が空白区切りで１行に与えられます。
データセットの数は 12000 を超えません。
Output
------
入力データセットごとに、ヒットの数とブローの数を１行に出力します。
Sample Input
------------
```
1234 5678
1234 1354
1234 1234
1230 1023
0123 1234
0 0
```
Output for the Sample Input
---------------------------
```
0 0
2 1
4 0
1 3
0 3
```
|
#include<iostream>
int main(){
int f[2],i,j;
std::string r,a;
while(std::cin>>r>>a,r!="0"&&a!="0"){
for(f[0]=f[1]=i=0;i<4;i++)for(j=4;j-->0;)if(a[i]==r[j])f[i!=j]++;
std::cout<<f[0]<<" "<<f[1]<<"\n";
}
} | #include<cstdio>
int main(){int h,b,i,j;char r[5],a[5];while(scanf("%s%s",r,a),r[1]!='\0'&&a[1]!='\0'){for(h=b=i=0;i<4;i++)for(j=4;j-->0;)if(a[i]==r[j])i==j?h++:b++;printf("%d %d\n",h,b);}} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
人生ゲーム
=====
太郎君は、おもちゃ屋さんに会津ホビー社製の人生ゲームを買いに行きました。人生ゲームは、マス目の書かれたボードとルーレットを使って遊びます。ボードには図のようにスタート地点とゴール地点が一つずつあり、それらはひとつながりのマス目でつながっています。最初に、コマはスタート地点のマスに置かれ、ルーレットを回して出た数によってコマを進めます。マスによっては、そこに止まったり通過したりすることでお金を得たり、コマの位置を変えたりするイベントマスがあります。最終的な勝敗は、コマがゴール地点に到達した時点の所持金の多寡で決まります。
この会社の人生ゲームの面白いところは、ルーレットの出る目の大きさ、ゴールまでのマスの数、イベントマスの配置がひとつひとつパッケージごとに異なるところです。それらはケースに書かれており、それを読むことで確認することができます。お金を最も得られる人生ゲームを選びたい太郎君は、得るお金の期待値が一番大きいものを買いたがっています。そこであなたは、太郎君のゲーム選びを手伝うことにしました。
ルーレットは、円周を X 等分に区分され、それぞれに V1、V2、...、VX という値が記入されているとします。ボードには、0 番、1 番、...、Y 番と番号がふられたマス目があり、順番につながっています。マス目の中には、イベントマスと呼ばれる特別なマスが Z 個あり、そこに到達すると特別な動作を行います。イベントマスのマス目の番号は Ni で与えられます。イベントマスには 1 ~ 3 の種類 (Ei) があり、それぞれ次の動作が行われます。
| 種類 (Ei) | 特別動作 | 値 (Ai) の範囲 |
| --- | --- | --- |
| 1 | 指定の値 Ai だけ先へ進む | 1~10 |
| 2 | 指定の値 Ai の金額を得る | 1~100 |
| 3 | 指定の値 Ai の金額を支払う | 1~100 |
最初の所持金は 0 円で、第 0 マス目からスタートし、第 Y マス目に到達するとゴールとなります。ゴールを越えた場合もゴールと見なします。スタートとゴールにイベントは無く、1 マスに複数のイベントが重なることはありません。イベントによって進んだ先のマスのイベントは無視します。所持金が 0 円より少なくなる場合は 0 円とします。
例えば、ある人生ゲームで得られるお金の期待値は以下のように計算できます。
この例では、スタート、イベントマス(100 円入手) 、ゴールの 3 つのマスと、1 か 2 が出るルーレットからなる人生ゲームが表されています。まず、1 回目にルーレットを回した時、1 が出ればイベントマスに到達し、所持金は 100 円になります。一方、2 が出た場合はゴールに到達し、所持金は 0 円のままです。これらはどちらも 2 分の 1 の確率で起こります。
さらに、1 回目でイベントマスに到達した場合は 2 回目のルーレットを回しますが、どの値が出てもゴールに到達し、所持金はどの場合も 100 円です。
このように、全部で 3 通りのゴールの仕方があります。ゴールした時点の所持金に着目すると、0 円になる場合が 1 通りでその確率は 2 分の 1、100 円になる場合が 2 通りでその確率が 4 分の 1 です。この場合、ゴールでの所持金の期待値は、ゴールの仕方ごとの (所持金 × その確率) を足した値であり、この人生ゲームの期待値は 50 円になります。
ルーレットの情報とボードの情報を入力とし、ゴール時の所持金の期待値を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下の形式で与えられます。
```
X Y Z
V1 V2 ... VX
N1 E1 A1
N2 E2 A2
:
NZ EZ AZ
```
X (1 ≤ X ≤ 4)、Vi (1 ≤ Vi ≤ 10)、Y (1 ≤ Y ≤ 50)、Ni (1 ≤ Ni ≤ Y-1)、Z (0 ≤ Z ≤ Y-1)、Ei (1 ≤ Ei ≤ 3)、 Ai (1 ≤ Ai ≤ 100) は整数で与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、最終的な所持金の期待値を１行に出力します。なお、所持金の期待値は小数点以下切り捨ての整数で出力してください。
Sample Input
------------
```
1 2 0
1
1 2 1
1
1 2 100
1 2 1
2
1 2 100
2 2 1
1 2
1 2 100
4 5 3
1 2 3 4
1 1 2
2 2 100
4 3 60
0 0 0
```
Output for the Sample Input
---------------------------
```
0
100
0
50
20
```
| #include<iostream>
#include<algorithm>
#define FOR(i,e) for(int i=0;i<(int)(e);i++)
using namespace std;
int main(){
double pb[100][5001];
int x,y,z;
int v[4],e[51],a[51];
while(cin >> x >> y >> z && (x||y||z)){
FOR(i,x)cin >> v[i];
FOR(i,y+1)e[i] = a[i] = 0;
FOR(i,z){
int n,m,l;
cin >> n >> m >> l;
e[n] = m; a[n] = l;
}
FOR(i,y+1)FOR(j,5001)pb[i][j] = 0.0;
pb[0][0] = 1.0;
FOR(i,y)FOR(j,5001){
FOR(k,x){
if(pb[i][j] == 0.0)continue;
int next = min(y,i+v[k]),value = j;
if(e[next] == 1)next = min(y,next+a[next]);
else if(e[next] == 2)value = j + a[next];
else if(e[next] == 3)value = max(0,j-a[next]);
pb[next][value] += pb[i][j]/x;
}
}
double ans = 0.0;
FOR(i,5001)ans += pb[y][i] * i;
cout << (int)(ans) << endl;
}
} | #include<cstdio>
#include<algorithm>
using namespace std;
int main(){
double pb[100][5001];
int x,y,z,n,m,l,ub,i,j,k;
int v[4],e[51],a[51];
while(scanf("%d %d %d",&x,&y,&z) && (x||y||z)){
for(i=0;i<x;i++)scanf("%d",&v[i]);
for(i=0;i<=y;i++)e[i] = a[i] = 0;
ub = 0;
for(i=0;i<z;i++){
scanf("%d %d %d",&n,&m,&l);
e[n] = m; a[n] = l;
if(m==2)ub += a[n];
}
for(i=0;i<=y;i++)
for(j=0;j<=ub;j++)pb[i][j] = 0.0;
pb[0][0] = 1.0;
for(i=0;i<y;i++)
for(j=0;j<=ub;j++){
if(pb[i][j] == 0.0)continue;
for(k=0;k<x;k++){
n = min(y,i+v[k]),m = j;
if(e[n] == 1)n = min(y,n+a[n]);
else if(e[n] == 2)m = j + a[n];
else if(e[n] == 3)m = max(0,j-a[n]);
pb[n][m] += pb[i][j]/x;
}
}
double ans = 0.0;
for(i=0;i<=ub;i++)ans += pb[y][i] * i;
printf("%d\n",(int)ans);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
人生ゲーム
=====
太郎君は、おもちゃ屋さんに会津ホビー社製の人生ゲームを買いに行きました。人生ゲームは、マス目の書かれたボードとルーレットを使って遊びます。ボードには図のようにスタート地点とゴール地点が一つずつあり、それらはひとつながりのマス目でつながっています。最初に、コマはスタート地点のマスに置かれ、ルーレットを回して出た数によってコマを進めます。マスによっては、そこに止まったり通過したりすることでお金を得たり、コマの位置を変えたりするイベントマスがあります。最終的な勝敗は、コマがゴール地点に到達した時点の所持金の多寡で決まります。
この会社の人生ゲームの面白いところは、ルーレットの出る目の大きさ、ゴールまでのマスの数、イベントマスの配置がひとつひとつパッケージごとに異なるところです。それらはケースに書かれており、それを読むことで確認することができます。お金を最も得られる人生ゲームを選びたい太郎君は、得るお金の期待値が一番大きいものを買いたがっています。そこであなたは、太郎君のゲーム選びを手伝うことにしました。
ルーレットは、円周を X 等分に区分され、それぞれに V1、V2、...、VX という値が記入されているとします。ボードには、0 番、1 番、...、Y 番と番号がふられたマス目があり、順番につながっています。マス目の中には、イベントマスと呼ばれる特別なマスが Z 個あり、そこに到達すると特別な動作を行います。イベントマスのマス目の番号は Ni で与えられます。イベントマスには 1 ~ 3 の種類 (Ei) があり、それぞれ次の動作が行われます。
| 種類 (Ei) | 特別動作 | 値 (Ai) の範囲 |
| --- | --- | --- |
| 1 | 指定の値 Ai だけ先へ進む | 1~10 |
| 2 | 指定の値 Ai の金額を得る | 1~100 |
| 3 | 指定の値 Ai の金額を支払う | 1~100 |
最初の所持金は 0 円で、第 0 マス目からスタートし、第 Y マス目に到達するとゴールとなります。ゴールを越えた場合もゴールと見なします。スタートとゴールにイベントは無く、1 マスに複数のイベントが重なることはありません。イベントによって進んだ先のマスのイベントは無視します。所持金が 0 円より少なくなる場合は 0 円とします。
例えば、ある人生ゲームで得られるお金の期待値は以下のように計算できます。
この例では、スタート、イベントマス(100 円入手) 、ゴールの 3 つのマスと、1 か 2 が出るルーレットからなる人生ゲームが表されています。まず、1 回目にルーレットを回した時、1 が出ればイベントマスに到達し、所持金は 100 円になります。一方、2 が出た場合はゴールに到達し、所持金は 0 円のままです。これらはどちらも 2 分の 1 の確率で起こります。
さらに、1 回目でイベントマスに到達した場合は 2 回目のルーレットを回しますが、どの値が出てもゴールに到達し、所持金はどの場合も 100 円です。
このように、全部で 3 通りのゴールの仕方があります。ゴールした時点の所持金に着目すると、0 円になる場合が 1 通りでその確率は 2 分の 1、100 円になる場合が 2 通りでその確率が 4 分の 1 です。この場合、ゴールでの所持金の期待値は、ゴールの仕方ごとの (所持金 × その確率) を足した値であり、この人生ゲームの期待値は 50 円になります。
ルーレットの情報とボードの情報を入力とし、ゴール時の所持金の期待値を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下の形式で与えられます。
```
X Y Z
V1 V2 ... VX
N1 E1 A1
N2 E2 A2
:
NZ EZ AZ
```
X (1 ≤ X ≤ 4)、Vi (1 ≤ Vi ≤ 10)、Y (1 ≤ Y ≤ 50)、Ni (1 ≤ Ni ≤ Y-1)、Z (0 ≤ Z ≤ Y-1)、Ei (1 ≤ Ei ≤ 3)、 Ai (1 ≤ Ai ≤ 100) は整数で与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、最終的な所持金の期待値を１行に出力します。なお、所持金の期待値は小数点以下切り捨ての整数で出力してください。
Sample Input
------------
```
1 2 0
1
1 2 1
1
1 2 100
1 2 1
2
1 2 100
2 2 1
1 2
1 2 100
4 5 3
1 2 3 4
1 1 2
2 2 100
4 3 60
0 0 0
```
Output for the Sample Input
---------------------------
```
0
100
0
50
20
```
| #include<iostream>
#include<string>
#include<algorithm>
#include<cctype>
#include<vector>
#include<map>
#include<iomanip>
using namespace std;
#define fr first
#define sc second
typedef pair<int,int> P;
int main(){
int X,Y,Z,N,E,A;
while(cin >> X >> Y >> Z , X){
int jump[X];
P ivent[Y+1];
for(int i = 0 ; i <= Y ; i++ ) ivent[i] = P( 0 , 0 );
double dp[51][5001]={{}};
dp[0][0] = 1.0;
for(int i = 0 ; i < X ; i++ ){
cin >> jump[i];
}
for(int i = 0 ; i < Z ; i++ ){
cin >> N >> E >> A;
switch(E){
case 1: ivent[N].fr = A; break;
case 2: ivent[N].sc = A; break;
case 3: ivent[N].sc = -A; break;
}
}
for(int i = 0 , limit = 0 ; i < Y ; i++ , limit += 100 ){
for(int j = 0 ; j <= limit ; j++ ){
if(dp[i][j]){
for(int k = 0 , p_mas , p_money ; k < X ; k++ ){
p_mas = min( i + jump[k] , Y );
p_money = max(0,ivent[p_mas].sc + j );
p_mas = min( p_mas + ivent[p_mas].fr , Y );
dp[p_mas][p_money] += dp[i][j] / X;
}
}
}
}
double ans = 0.0;
for(int i = 0 ; i < 5001 ; i++ ){
ans += dp[Y][i] * i;
}
cout << (int)ans << endl;
}
} | #include<iostream>
#include<string>
#include<algorithm>
#include<cctype>
#include<vector>
#include<map>
#include<iomanip>
using namespace std;
#define fr first
#define sc second
typedef pair<int,int> P;
int main(){
int X,Y,Z,N,E,A;
double dp[51][5001];
int jump[4];
P ivent[51];
while(cin >> X >> Y >> Z , X){
for(int i = 0 , limit = 0 ; i <= Y ; i++ , limit += 100 ){
ivent[i] = P( 0 , 0 );
for(int j = 0 ; j <= limit ; j++ ) dp[i][j] = 0.0;
}
dp[0][0] = 1.0;
for(int i = 0 ; i < X ; i++ ){
cin >> jump[i];
}
for(int i = 0 ; i < Z ; i++ ){
cin >> N >> E >> A;
switch(E){
case 1: ivent[N].fr = A; break;
case 2: ivent[N].sc = A; break;
case 3: ivent[N].sc = -A; break;
}
}
for(int i = 0 , limit = 0 ; i < Y ; i++ , limit += 100 ){
for(int j = 0 ; j <= limit ; j++ ){
if(dp[i][j]){
for(int k = 0 , p_mas , p_money ; k < X ; k++ ){
p_mas = min( i + jump[k] , Y );
p_money = max(0,ivent[p_mas].sc + j );
p_mas = min( p_mas + ivent[p_mas].fr , Y );
dp[p_mas][p_money] += dp[i][j] / X;
}
}
}
}
double ans = 0.0;
for(int i = 0 ; i < 5001 ; i++ ){
ans += dp[Y][i] * i;
}
cout << (int)ans << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
人生ゲーム
=====
太郎君は、おもちゃ屋さんに会津ホビー社製の人生ゲームを買いに行きました。人生ゲームは、マス目の書かれたボードとルーレットを使って遊びます。ボードには図のようにスタート地点とゴール地点が一つずつあり、それらはひとつながりのマス目でつながっています。最初に、コマはスタート地点のマスに置かれ、ルーレットを回して出た数によってコマを進めます。マスによっては、そこに止まったり通過したりすることでお金を得たり、コマの位置を変えたりするイベントマスがあります。最終的な勝敗は、コマがゴール地点に到達した時点の所持金の多寡で決まります。
この会社の人生ゲームの面白いところは、ルーレットの出る目の大きさ、ゴールまでのマスの数、イベントマスの配置がひとつひとつパッケージごとに異なるところです。それらはケースに書かれており、それを読むことで確認することができます。お金を最も得られる人生ゲームを選びたい太郎君は、得るお金の期待値が一番大きいものを買いたがっています。そこであなたは、太郎君のゲーム選びを手伝うことにしました。
ルーレットは、円周を X 等分に区分され、それぞれに V1、V2、...、VX という値が記入されているとします。ボードには、0 番、1 番、...、Y 番と番号がふられたマス目があり、順番につながっています。マス目の中には、イベントマスと呼ばれる特別なマスが Z 個あり、そこに到達すると特別な動作を行います。イベントマスのマス目の番号は Ni で与えられます。イベントマスには 1 ~ 3 の種類 (Ei) があり、それぞれ次の動作が行われます。
| 種類 (Ei) | 特別動作 | 値 (Ai) の範囲 |
| --- | --- | --- |
| 1 | 指定の値 Ai だけ先へ進む | 1~10 |
| 2 | 指定の値 Ai の金額を得る | 1~100 |
| 3 | 指定の値 Ai の金額を支払う | 1~100 |
最初の所持金は 0 円で、第 0 マス目からスタートし、第 Y マス目に到達するとゴールとなります。ゴールを越えた場合もゴールと見なします。スタートとゴールにイベントは無く、1 マスに複数のイベントが重なることはありません。イベントによって進んだ先のマスのイベントは無視します。所持金が 0 円より少なくなる場合は 0 円とします。
例えば、ある人生ゲームで得られるお金の期待値は以下のように計算できます。
この例では、スタート、イベントマス(100 円入手) 、ゴールの 3 つのマスと、1 か 2 が出るルーレットからなる人生ゲームが表されています。まず、1 回目にルーレットを回した時、1 が出ればイベントマスに到達し、所持金は 100 円になります。一方、2 が出た場合はゴールに到達し、所持金は 0 円のままです。これらはどちらも 2 分の 1 の確率で起こります。
さらに、1 回目でイベントマスに到達した場合は 2 回目のルーレットを回しますが、どの値が出てもゴールに到達し、所持金はどの場合も 100 円です。
このように、全部で 3 通りのゴールの仕方があります。ゴールした時点の所持金に着目すると、0 円になる場合が 1 通りでその確率は 2 分の 1、100 円になる場合が 2 通りでその確率が 4 分の 1 です。この場合、ゴールでの所持金の期待値は、ゴールの仕方ごとの (所持金 × その確率) を足した値であり、この人生ゲームの期待値は 50 円になります。
ルーレットの情報とボードの情報を入力とし、ゴール時の所持金の期待値を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下の形式で与えられます。
```
X Y Z
V1 V2 ... VX
N1 E1 A1
N2 E2 A2
:
NZ EZ AZ
```
X (1 ≤ X ≤ 4)、Vi (1 ≤ Vi ≤ 10)、Y (1 ≤ Y ≤ 50)、Ni (1 ≤ Ni ≤ Y-1)、Z (0 ≤ Z ≤ Y-1)、Ei (1 ≤ Ei ≤ 3)、 Ai (1 ≤ Ai ≤ 100) は整数で与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、最終的な所持金の期待値を１行に出力します。なお、所持金の期待値は小数点以下切り捨ての整数で出力してください。
Sample Input
------------
```
1 2 0
1
1 2 1
1
1 2 100
1 2 1
2
1 2 100
2 2 1
1 2
1 2 100
4 5 3
1 2 3 4
1 1 2
2 2 100
4 3 60
0 0 0
```
Output for the Sample Input
---------------------------
```
0
100
0
50
20
```
| #include <cstdio>
#include <map>
//#define scanf scanf_s
const int kMaxSquare = 64;
int roulette[4];
typedef struct{
int type;
int value;
} BoardState;
BoardState board[kMaxSquare];
int bp(int X, int Y){
std::map<int, double> bp[kMaxSquare];
double prob = 1.0f / static_cast<double>(X);
bp[0][0] = 1.0f;
for (int n = 0; n < Y; n++){
for (std::map<int, double>::iterator it = bp[n].begin(); it != bp[n].end(); it++){
for (int k = 0; k < X; k++){
int pos = (n + roulette[k] < Y) ? n + roulette[k] : Y;
if (board[pos].type == 1)
bp[(pos + board[pos].value < Y) ? pos + board[pos].value : Y][it->first]
+= it->second * prob;
else if (board[pos].type == 2)
bp[pos][it->first + board[pos].value] += it->second * prob;
else if (board[pos].type == 3)
bp[pos][(it->first - board[pos].value > 0) ? it->first - board[pos].value : 0]
+= it->second * prob;
else
bp[pos][it->first] += it->second * prob;
}
}
}
double res = 0.0f;
for (std::map<int, double>::iterator it = bp[Y].begin(); it != bp[Y].end(); it++)
res += static_cast<double>(it->first) * it->second;
return static_cast<int>(res);
}
int main(){
while (1){
int X, Y, Z; //X:????????¬?????????????????°, Y: ??????????????°(???: ????????????), Z: ???????????????????????°
scanf("%d %d %d", &X, &Y, &Z);
if (X == 0) return 0;
for (int i = 0; i < X; i++)
scanf("%d", &roulette[i]);
for (int i = 0; i < kMaxSquare; i++)
board[i] = { 0, 0 };
for (; Z > 0; Z--){
int N, E, A; //N: ?????????, E: ??????????¨????, A: ??????????????§????????° or ?¢????????????????
scanf("%d %d %d", &N, &E, &A);
board[N] = { E, A };
}
printf("%d\n", bp(X, Y));
}
} | #include <cstdio>
#include <algorithm>
//#define scanf scanf_s
const int kMaxSquare = 64;
const int kMaxMoney = 5100;
const int kMaxGainMoney = 100;
int roulette[4];
typedef struct{
int type;
int value;
} BoardState;
BoardState board[kMaxSquare];
int bp(int X, int Y){
float bp[kMaxSquare][kMaxMoney];
float prob = 1.0f / static_cast<float>(X);
for(int n = 0; n <= Y; n++)
for(int m = 0; m <= Y*kMaxGainMoney; m++)
bp[n][m] = 0.0f;
bp[0][0] = 1.0f;
for (int n = 0; n < Y; n++){
int mmax = n * kMaxGainMoney;
for (int m = 0; m <= mmax; m++){
if(bp[n][m] == 0.0f) continue;
for (int k = 0; k < X; k++){
int pos = std::min(n+roulette[k], Y);
if (board[pos].type == 1)
bp[std::min(pos + board[pos].value, Y)][m] += bp[n][m] * prob;
else if (board[pos].type == 2)
bp[pos][m + board[pos].value] += bp[n][m]* prob;
else if (board[pos].type == 3)
bp[pos][std::max(m - board[pos].value, 0)] += bp[n][m] * prob;
else
bp[pos][m] += bp[n][m] * prob;
}
}
}
float res = 0.0f;
int mmax = Y * kMaxGainMoney;
for (int m = 0; m <= mmax; m++)
res += static_cast<float>(m) * bp[Y][m];
return static_cast<int>(res);
}
int main(){
while (1){
int X, Y, Z;
scanf("%d %d %d", &X, &Y, &Z);
if (X == 0) return 0;
for (int i = 0; i < X; i++)
scanf("%d", &roulette[i]);
for (int i = 0; i < kMaxSquare; i++)
board[i] = { 0, 0 };
for (; Z > 0; Z--){
int N, E, A;
scanf("%d %d %d", &N, &E, &A);
board[N] = { E, A };
}
printf("%d\n", bp(X, Y));
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
人生ゲーム
=====
太郎君は、おもちゃ屋さんに会津ホビー社製の人生ゲームを買いに行きました。人生ゲームは、マス目の書かれたボードとルーレットを使って遊びます。ボードには図のようにスタート地点とゴール地点が一つずつあり、それらはひとつながりのマス目でつながっています。最初に、コマはスタート地点のマスに置かれ、ルーレットを回して出た数によってコマを進めます。マスによっては、そこに止まったり通過したりすることでお金を得たり、コマの位置を変えたりするイベントマスがあります。最終的な勝敗は、コマがゴール地点に到達した時点の所持金の多寡で決まります。
この会社の人生ゲームの面白いところは、ルーレットの出る目の大きさ、ゴールまでのマスの数、イベントマスの配置がひとつひとつパッケージごとに異なるところです。それらはケースに書かれており、それを読むことで確認することができます。お金を最も得られる人生ゲームを選びたい太郎君は、得るお金の期待値が一番大きいものを買いたがっています。そこであなたは、太郎君のゲーム選びを手伝うことにしました。
ルーレットは、円周を X 等分に区分され、それぞれに V1、V2、...、VX という値が記入されているとします。ボードには、0 番、1 番、...、Y 番と番号がふられたマス目があり、順番につながっています。マス目の中には、イベントマスと呼ばれる特別なマスが Z 個あり、そこに到達すると特別な動作を行います。イベントマスのマス目の番号は Ni で与えられます。イベントマスには 1 ~ 3 の種類 (Ei) があり、それぞれ次の動作が行われます。
| 種類 (Ei) | 特別動作 | 値 (Ai) の範囲 |
| --- | --- | --- |
| 1 | 指定の値 Ai だけ先へ進む | 1~10 |
| 2 | 指定の値 Ai の金額を得る | 1~100 |
| 3 | 指定の値 Ai の金額を支払う | 1~100 |
最初の所持金は 0 円で、第 0 マス目からスタートし、第 Y マス目に到達するとゴールとなります。ゴールを越えた場合もゴールと見なします。スタートとゴールにイベントは無く、1 マスに複数のイベントが重なることはありません。イベントによって進んだ先のマスのイベントは無視します。所持金が 0 円より少なくなる場合は 0 円とします。
例えば、ある人生ゲームで得られるお金の期待値は以下のように計算できます。
この例では、スタート、イベントマス(100 円入手) 、ゴールの 3 つのマスと、1 か 2 が出るルーレットからなる人生ゲームが表されています。まず、1 回目にルーレットを回した時、1 が出ればイベントマスに到達し、所持金は 100 円になります。一方、2 が出た場合はゴールに到達し、所持金は 0 円のままです。これらはどちらも 2 分の 1 の確率で起こります。
さらに、1 回目でイベントマスに到達した場合は 2 回目のルーレットを回しますが、どの値が出てもゴールに到達し、所持金はどの場合も 100 円です。
このように、全部で 3 通りのゴールの仕方があります。ゴールした時点の所持金に着目すると、0 円になる場合が 1 通りでその確率は 2 分の 1、100 円になる場合が 2 通りでその確率が 4 分の 1 です。この場合、ゴールでの所持金の期待値は、ゴールの仕方ごとの (所持金 × その確率) を足した値であり、この人生ゲームの期待値は 50 円になります。
ルーレットの情報とボードの情報を入力とし、ゴール時の所持金の期待値を出力するプログラムを作成してください。
Input
-----
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下の形式で与えられます。
```
X Y Z
V1 V2 ... VX
N1 E1 A1
N2 E2 A2
:
NZ EZ AZ
```
X (1 ≤ X ≤ 4)、Vi (1 ≤ Vi ≤ 10)、Y (1 ≤ Y ≤ 50)、Ni (1 ≤ Ni ≤ Y-1)、Z (0 ≤ Z ≤ Y-1)、Ei (1 ≤ Ei ≤ 3)、 Ai (1 ≤ Ai ≤ 100) は整数で与えられます。
データセットの数は 100 を超えません。
Output
------
入力データセットごとに、最終的な所持金の期待値を１行に出力します。なお、所持金の期待値は小数点以下切り捨ての整数で出力してください。
Sample Input
------------
```
1 2 0
1
1 2 1
1
1 2 100
1 2 1
2
1 2 100
2 2 1
1 2
1 2 100
4 5 3
1 2 3 4
1 1 2
2 2 100
4 3 60
0 0 0
```
Output for the Sample Input
---------------------------
```
0
100
0
50
20
```
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
const double EPS = 1e-8;
typedef long long ll;
typedef pair<int, int> pint;
int main()
{
int x, y, z;
while (scanf("%d%d%d", &x, &y, &z), x|y|z)
{
double p = 1.0 / x;
int v[4], e[51], a[51];
for (int i = 0; i < x; ++i)
scanf("%d", v + i);
memset(e, 0, sizeof(e));
for (int i = 0; i < z; ++i)
{
int t;
scanf("%d", &t);
scanf("%d%d", e + t, a + t);
}
static double dp[51][5001];
for (int i = 0; i <= y; ++i)
for (int j = 0; j <= 5000; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < y; ++i)
{
for (int j = 0; j <= 5000; ++j)
{
for (int k = 0; k < x; ++k)
{
int to = min(y, i + v[k]);
int money = j;
if (e[to] == 1)
to = min(y, to + a[to]);
else if (e[to] == 2)
money = min(5000, money + a[to]);
else if (e[to] == 3)
money = max(0, money - a[to]);
dp[to][money] += dp[i][j] * p;
}
}
}
double res = 0;
for (int i = 0; i <= 5000; ++i)
res += i * dp[y][i];
printf("%d\n", (int)res);
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T>
int __builtin_popcount(T n) { return n ? 1 + __builtin_popcount(n & (n - 1)) : 0; }
#endif
#define foreach(it, c) for (__typeof__((c).begin()) it=(c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
const double EPS = 1e-8;
typedef long long ll;
typedef pair<int, int> pint;
int main()
{
int x, y, z;
while (scanf("%d%d%d", &x, &y, &z), x|y|z)
{
float p = 1.0 / x;
int v[4], e[51], a[51];
for (int i = 0; i < x; ++i)
scanf("%d", v + i);
memset(e, 0, sizeof(e));
for (int i = 0; i < z; ++i)
{
int t;
scanf("%d", &t);
scanf("%d%d", e + t, a + t);
}
int max_money = 0;
for (int i = 0; i < y; ++i)
if (e[i] == 2)
max_money += a[i];
static float dp[51][5001];
for (int i = 0; i <= y; ++i)
for (int j = 0; j <= max_money; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < y; ++i)
{
for (int j = 0; j <= max_money; ++j)
{
if (dp[i][j] == 0)
continue;
for (int k = 0; k < x; ++k)
{
int to = min(y, i + v[k]);
int money = j;
if (e[to] == 1)
to = min(y, to + a[to]);
else if (e[to] == 2)
money += a[to];
else if (e[to] == 3)
money = max(0, money - a[to]);
dp[to][money] += dp[i][j] * p;
}
}
}
float res = 0;
for (int i = 0; i <= max_money; ++i)
res += i * dp[y][i];
printf("%d\n", (int)res);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
温泉旅行
====
温泉好きのたけしさんは、次の長期休暇を利用してとある温泉地への旅行を計画しています。移動は長距離バスを乗り継ぎ、なるべくお金をかけずに目的地へたどり着きたいと思っています。貯金があるとはいえ、資金に心許ないたけしさんは、おじいさんに相談することにしました。計画を聞いて感心したおじいさんは、たけしさんに特別な切符を渡しました。
その切符は、長距離バスの連続した2区間を1回だけ無料で乗れるというものでした。使いようによってはかなりの移動費削減が見込めますが、より大きな効果を発揮させるためにはしっかりした計画を練る必要があります。
出発地と目的地、及び中継地点が合わせて n 個、2つの地点を結ぶ路線が m 個与えられます。各地点にはそれぞれ 1 から n までの数字が割り振られています。出発地は 1、目的地は n です。路線の情報は、その路線が結ぶ2つの地点 a と b、及びその料金 c で表されます。特別な切符の効力により、任意の地点から、一度だけ連続した2つの路線を料金0で通過することができます。ただし、途中で目的地を通過しても、目的地にたどり着いたことにはなりません。
出発地、目的地、及び中継地点の総数 n と路線の数 m、各路線の情報を入力とし、料金の最小値を出力するプログラムを作成してください。ただし、必ず出発地から目的地へと到達する経路が存在するものとします。
入力
--
複数のデータセットが与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。
```
n m
a1 b1 c1
a2 b2 c2
:
am bm cm
```
1行目に出発地、目的地、及び中継地点の総数 n (2 ≤ n ≤ 100)と路線の数 m (1 ≤ m ≤ 300)が与えられます。続く m 行に各路線の情報 ai, bi, ci (1 ≤ ci ≤ 1000) が与えられます。
データセットの数は 40 を超えません。
出力
--
入力データセットごとに、料金の最小値を1行に出力します。
入力例
---
```
2 1
1 2 5
3 2
1 2 5
2 3 5
6 9
1 2 7
1 3 9
1 5 14
2 3 10
2 4 15
3 4 11
3 5 2
4 5 9
4 6 8
0 0
```
出力例
---
```
5
0
7
```
| #include <stdio.h>
#include <cctype>
#include <limits.h>
#include <math.h>
#include <complex>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x);
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
const int INF = 1000000000;
const double EPS = 1e-8;
const double PI = 3.14159;
int dx[4]={0, 1, 0, -1}, dy[4]={-1, 0, 1, 0};
using namespace std;
//typedef pair<int, int> P;
struct P {
int x, y;
P(int x, int y):x(x), y(y){}
P(){}
};
/** Problem0244 : Hot Spring Trip **/
int cost[300][300];
int main()
{
int N, M;
while (cin>>N>>M, N||M) {
rep(i, 300) rep(j, 300)
cost[i][j] = i==j?0:INF;
rep(i, M) {
int a, b, c; cin>>a>>b>>c;
a--, b--;
cost[a][b] = cost[b][a] = c;
}
vector<P> can_free;
rep(i, N) {
rep(j, N) {
if (cost[i][j]!=INF && i!=j) {
rep(k, N) {
if (cost[j][k]!=INF && i!=k && j!=k)
can_free.push_back(P(i, k));
}
}
}
}
rep(k, N) {
rep(i, N) {
rep(j, N) {
cost[i][j] = min(cost[i][j], cost[i][k]+cost[k][j]);
}
}
}
int ans=cost[0][N-1];
rep(i, can_free.size()) {
ans = min(cost[0][can_free[i].x]+cost[can_free[i].y][N-1], ans);
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define DEBUG(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define is_in(x, y, w, h) (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
int dx[4]={0, -1, 1, 0}, dy[4]={-1, 0, 0, 1};
using namespace std;
typedef long long ll;
typedef vector<vector<int> > VVI;
const int INF = 1e9;
typedef pair<int, int> PII;
const int V_MAX = 100;
struct Edge {
int to, cost;
Edge(int _to, int _cost) : to(_to), cost(_cost) {}
};
vector<Edge> G[V_MAX];
vector<int> go_free[V_MAX];
struct State {
int v, ticket, d;
State (int _v, int _ticket, int _d) : v(_v), ticket(_ticket), d(_d) {}
bool operator > (const State &b) const {return d > b.d;}
};
int main()
{
int N, M;
while (cin>>N>>M, N||M) {
rep(i, N) G[i].clear();
rep(i, N) go_free[i].clear();
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
A--, B--;
G[A].emplace_back(B, C);
G[B].emplace_back(A, C);
}
for (int i=0; i<N; i++) {
for (auto g : G[i]) {
for (auto h : G[g.to]) {
if (h.to != i) {
go_free[i].push_back(h.to);
// cerr << "free : (" << i << ", "<< h.to << ")" << endl;
}
}
}
}
priority_queue<State, vector<State>, greater<State>> Q;
map<PII, int> d;
d[PII(0, 1)] = 0;
Q.push(State(0, 1, 0));
int ans;
while (Q.size()) {
State s = Q.top(); Q.pop();
// cerr << s.v << " " << s.ticket << " " << s.d << endl;
if (s.v == N-1) {
ans = s.d;
break;
}
if (d.count(PII(s.v, s.ticket)) && d[PII(s.v, s.ticket)] < s.d) continue;
// no ticket
for (auto e : G[s.v]) {
int new_cost = d[PII(s.v, s.ticket)] + e.cost;
if (!d.count(PII(e.to, s.ticket)) || d[PII(e.to, s.ticket)] > new_cost) {
d[PII(e.to, s.ticket)] = new_cost;
Q.push(State(e.to, s.ticket, new_cost));
}
}
// with ticket
if (s.ticket) {
for (auto i : go_free[s.v]) {
if (!d.count(PII(i, 0)) || d[PII(i, 0)] > s.d) {
d[PII(i, 0)] = s.d;
Q.push(State(i, 0, s.d));
}
}
}
}
cout << ans << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
アリの巣箱の形状
========
求悟君は夏休みの自由研究としてアリの巣の観察を行うことにしました。彼のおじいちゃんが孫のために用意してくれた観察用の透明ケースはとてもユニークで、図1のような形をしています。
図１
このケースは、2枚の合同な凸多角形 s1、s2 と何枚かの長方形で構成されています。s1、s2 以外のいずれかの長方形の面を床に接するように置きます。観察を始めた求悟君は、入っている土の量が同じにもかかわらず、底面の選び方によって土の高さが変わることに気付きました（図2）。
図２
求悟君は、ケースの置き方によって、どのくらい高くなるか知りたくなりました。凸多角形 s1 の形、s1 と s2 間の距離 d、土の体積 V を入力とし、土の高さの最大値を出力するプログラムを作成してください。土は、ケースの底面を床に置くとすぐに水平になるものとします。透明ケースの s1 の形は、二次元の座標平面上の n 個の頂点で与えられます。これらの頂点は、反時計回りの順番で入力されます。n は 3 以上 100 以下で、d と V はそれぞれ 1 以上 10,000 以下の整数とします。また、多角形の頂点の座標 (x, y) の x、y はそれぞれ -1,000 以上 1,000 以下の整数とします。Vはケースの体積を超えません。
入力
--
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下のとおりです。
1 行目 n d V（整数 整数 整数；半角空白区切り）
2 行目 第 1 の頂点の座標 x y（整数 整数；半角空白区切り）
3 行目 第 2 の頂点の座標
:
n+1 行目 第 n の頂点の座標
データセットの数は 20 を超えません。
出力
--
入力データセットごとに、土の高さの最大値を出力します。答えには 0.00001 を越える誤差があってはいけません。
入力例
---
```
4 1 1
0 0
1 0
1 2
0 2
0 0 0
```
出力例
---
```
1.000000
```
| #include <bits/stdc++.h>
#define x real()
#define y imag()
#define EPS 0.0000001
using namespace std;
typedef complex<double> point;
double dot(point a,point b){return a.x*b.x+a.y*b.y;}
double cross(point a,point b){return a.x*b.y-a.y*b.x;}
int ccw(point a,point b,point c){
point d = b-a,e = c-a;
if(cross(d,e)>0) return 1;//"COUNTER_CLOCKWISE"
if(cross(d,e)<0) return -1;//"CLOCKWISE"
if(dot(d,e)<0) return 2;//"ONLINE_BACK"
if(abs(d) < abs(e)) return -2;//"ONLINE_FRONT"
return 0;//"ON_SEGMENT"
}
point crosspoint(point a,point b,point c,point d){
a-=d;b-=d;c-=d;
return d+a+(b-a)*imag(a/c)/imag(a/c-b/c);
}
vector<point> ConvexCut(vector<point> &polygon,point a,point b){
vector <point> res;
for(int i=0;i<polygon.size();i++){
point A=polygon[i],B=polygon[(i+1)%polygon.size()];
if(ccw(a,b,A)!=-1)res.push_back(A);
if(ccw(a,b,A)*ccw(a,b,B)==-1)res.push_back(crosspoint(a,b,A,B));
}
return res;
}
double get_area(vector <point> &polygon){
if(polygon.size()<3)return 0;
double res=0;
for(int i=0;i<polygon.size();i++)
res+=cross(polygon[i],polygon[(i+1)%polygon.size()])/2;
return res;
}
int main(){
while(1){
int v,n,d;
vector <point> pl;
cin>>n>>d>>v;
if(!n&&!d&&!v) break;
for(int i=0,a,b;i<n;i++) cin>>a>>b,pl.push_back(point(a,b));
double V=min(get_area(pl)*d,(double)v),ans=0;
for(int i=0;i<n;i++){
double L=0,M,R=2010;
int I=1000;
while(I--){
M=(L+R)/2;
point h=pl[(i+1)%n]-pl[i],b=h;
h=(point(0,M)*h/abs(h))+pl[i];
if(ccw(pl[(i+1)%n],pl[i],h)*ccw(pl[(i+1)%n],pl[i],h+b)<=0)assert(0);
vector<point> a=ConvexCut(pl,h+b,h);
double res=get_area(a);
assert(res>0);
if(res*d>=V)R=M;
else L=M+0.000000001;
}
ans=max(ans,L);
}
assert(ans<2001&&ans>0.0001);
printf("%.8f\n",ans);
}
return 0;
} | #include <bits/stdc++.h>
#define x real()
#define y imag()
using namespace std;
typedef complex<double> point;
double dot(point a,point b){return a.x*b.x+a.y*b.y;}
double cross(point a,point b){return a.x*b.y-a.y*b.x;}
int ccw(point a,point b,point c){
point d = b-a,e = c-a;
if(cross(d,e)>0) return 1;//"COUNTER_CLOCKWISE"
if(cross(d,e)<0) return -1;//"CLOCKWISE"
if(dot(d,e)<0) return 2;//"ONLINE_BACK"
if(abs(d) < abs(e)) return -2;//"ONLINE_FRONT"
return 0;//"ON_SEGMENT"
}
point crosspoint(point a,point b,point c,point d){
a-=d;b-=d;c-=d;
return d+a+(b-a)*imag(a/c)/imag(a/c-b/c);
}
vector<point> ConvexCut(vector<point> &polygon,point a,point b){
vector <point> res;
for(int i=0;i<polygon.size();i++){
point A=polygon[i],B=polygon[(i+1)%polygon.size()];
if(ccw(a,b,A)!=-1)res.push_back(A);
if(ccw(a,b,A)*ccw(a,b,B)==-1)res.push_back(crosspoint(a,b,A,B));
}
return res;
}
double get_area(vector <point> &polygon){
if(polygon.size()<3)return 0;
double res=0;
for(int i=0;i<polygon.size();i++)
res+=cross(polygon[i],polygon[(i+1)%polygon.size()])/2;
return res;
}
int main(){
while(1){
int n,d;
double V;
vector <point> pl;
cin>>n>>d>>V;
if(!n&&!d&&!V) break;
for(int i=0,a,b;i<n;i++) cin>>a>>b,pl.push_back(point(a,b));
V=min(get_area(pl)*d,V);
double ans=0;
for(int i=0;i<n;i++){
double L=0,M,R=2010;
int I=100;
while(I--){
M=(L+R)/2;
point h=pl[(i+1)%n]-pl[i],b=h;
h=(point(0,M)*h/abs(h))+pl[i];
vector<point> a=ConvexCut(pl,h+b,h);
if(get_area(a)*d>=V)R=M;
else L=M+0.00000001;
}
ans=max(ans,L);
}
printf("%.8f\n",ans);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
アリの巣箱の形状
========
求悟君は夏休みの自由研究としてアリの巣の観察を行うことにしました。彼のおじいちゃんが孫のために用意してくれた観察用の透明ケースはとてもユニークで、図1のような形をしています。
図１
このケースは、2枚の合同な凸多角形 s1、s2 と何枚かの長方形で構成されています。s1、s2 以外のいずれかの長方形の面を床に接するように置きます。観察を始めた求悟君は、入っている土の量が同じにもかかわらず、底面の選び方によって土の高さが変わることに気付きました（図2）。
図２
求悟君は、ケースの置き方によって、どのくらい高くなるか知りたくなりました。凸多角形 s1 の形、s1 と s2 間の距離 d、土の体積 V を入力とし、土の高さの最大値を出力するプログラムを作成してください。土は、ケースの底面を床に置くとすぐに水平になるものとします。透明ケースの s1 の形は、二次元の座標平面上の n 個の頂点で与えられます。これらの頂点は、反時計回りの順番で入力されます。n は 3 以上 100 以下で、d と V はそれぞれ 1 以上 10,000 以下の整数とします。また、多角形の頂点の座標 (x, y) の x、y はそれぞれ -1,000 以上 1,000 以下の整数とします。Vはケースの体積を超えません。
入力
--
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロみっつの行で示されます。各データセットは以下のとおりです。
1 行目 n d V（整数 整数 整数；半角空白区切り）
2 行目 第 1 の頂点の座標 x y（整数 整数；半角空白区切り）
3 行目 第 2 の頂点の座標
:
n+1 行目 第 n の頂点の座標
データセットの数は 20 を超えません。
出力
--
入力データセットごとに、土の高さの最大値を出力します。答えには 0.00001 を越える誤差があってはいけません。
入力例
---
```
4 1 1
0 0
1 0
1 2
0 2
0 0 0
```
出力例
---
```
1.000000
```
| #include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
const double EPS = 1e-9;
using number = double;
struct point {
number x, y;
point operator + (point r) { return point{x + r.x, y + r.y}; }
point operator + (const point& r) const { return point{x + r.x, y + r.y}; }
point operator - (point r) { return point{x - r.x, y - r.y}; }
point operator - (const point& r) const { return point{x - r.x, y - r.y}; }
point operator * (point r) { return point{x*r.x - y*r.y, x*r.y + r.x*y}; }
void operator -= (point r) { x -= r.x, y -= r.y; }
point nml() { return point{x/sqrt(x*x+y*y), y/sqrt(x*x+y*y)}; }
};
point operator * (number k, point p) { return point{k * p.x, k * p.y}; }
struct line {
point s, t;
};
typedef line segment;
number dot(point a, point b) {
return a.x*b.x + a.y*b.y;
}
number cross(point a, point b) {
return a.x*b.y - a.y*b.x;
}
number norm(point p) {
return p.x * p.x + p.y * p.y;
}
struct polygon : public vector<point> {
number area2() {
number ret{};
rep(i, this->size())
ret += cross((*this)[i],(*this)[(i+1)%this->size()]);
return abs(ret);
}
};
int ccw(point a, point b, point c) {
b -= a, c -= a;
if(cross(b, c) > +EPS) return +1;
if(cross(b, c) < -EPS) return -1;
if(dot(b, c) < -EPS) return +2;
if(norm(b) < norm(c)) return -2;
return 0;
}
point crosspoint(const line &l, const line &m) {
number A = cross(l.t - l.s, m.t - m.s);
number B = cross(l.t - l.s, l.t - m.s);
if(abs(A) < EPS && abs(B) < EPS) return m.s; // same line
if(abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
return m.s + B / A * (m.t - m.s);
}
polygon convex_cut(polygon& g, line& l) {
polygon ret{};
rep(i, g.size()) {
auto a = g[i], b = g[(i+1)%g.size()];
if(ccw(l.s, l.t, a) != -1) ret.push_back(a);
if(ccw(l.s, l.t, a) * ccw(l.s, l.t, b) < 0)
ret.push_back(crosspoint(line{a, b}, l));
}
return ret;
}
bool compare(polygon& g, number V, number D, int ridx, number height) {
line l{g[(ridx+1)%g.size()], g[ridx]};
point v = height * ((l.t - l.s) * point{0, -1}).nml();
l.s = l.s + v, l.t = l.t + v;
return convex_cut(g, l).area2() * D < V * 2;
}
int main() {
int N; number D, V;
while(cin >> N >> D >> V && (N||D||V)) {
polygon g{};
rep(i, N) {
number x, y; cin >> x >> y;
g.push_back(point{x, y});
}
number ans = 0;
rep(i, N) {
number l = 0, h = 114514;
rep(_, 300) {
number mid = (l + h) / 2;
(compare(g, V, D, i, mid) ? l : h) = mid;
}
ans = max(ans, l);
}
printf("%.10f\n", ans);
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
const double EPS = 1e-9;
using number = double;
struct point {
number x, y;
point operator + (point r) { return point{x + r.x, y + r.y}; }
point operator + (const point& r) const { return point{x + r.x, y + r.y}; }
point operator - (point r) { return point{x - r.x, y - r.y}; }
point operator - (const point& r) const { return point{x - r.x, y - r.y}; }
point operator * (point r) { return point{x*r.x - y*r.y, x*r.y + r.x*y}; }
void operator -= (point r) { x -= r.x, y -= r.y; }
point nml() { return point{x/sqrt(x*x+y*y), y/sqrt(x*x+y*y)}; }
};
point operator * (number k, point p) { return point{k * p.x, k * p.y}; }
struct line {
point s, t;
};
typedef line segment;
number dot(point a, point b) {
return a.x*b.x + a.y*b.y;
}
number cross(point a, point b) {
return a.x*b.y - a.y*b.x;
}
number norm(point p) {
return p.x * p.x + p.y * p.y;
}
struct polygon : public vector<point> {
number area2() {
number ret{};
rep(i, this->size())
ret += cross((*this)[i],(*this)[(i+1)%this->size()]);
return abs(ret);
}
};
int ccw(point a, point b, point c) {
b -= a, c -= a;
if(cross(b, c) > +EPS) return +1;
if(cross(b, c) < -EPS) return -1;
if(dot(b, c) < -EPS) return +2;
if(norm(b) < norm(c)) return -2;
return 0;
}
point crosspoint(const line &l, const line &m) {
number A = cross(l.t - l.s, m.t - m.s);
number B = cross(l.t - l.s, l.t - m.s);
if(abs(A) < EPS && abs(B) < EPS) return m.s; // same line
if(abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
return m.s + B / A * (m.t - m.s);
}
polygon convex_cut(polygon& g, line& l) {
polygon ret{};
rep(i, g.size()) {
auto a = g[i], b = g[(i+1)%g.size()];
if(ccw(l.s, l.t, a) != -1) ret.push_back(a);
if(ccw(l.s, l.t, a) * ccw(l.s, l.t, b) < 0)
ret.push_back(crosspoint(line{a, b}, l));
}
return ret;
}
bool compare(polygon& g, number V, number D, int ridx, number height) {
line l{g[(ridx+1)%g.size()], g[ridx]};
point v = height * ((l.t - l.s) * point{0, -1}).nml();
l.s = l.s + v, l.t = l.t + v;
return convex_cut(g, l).area2() * D < V * 2;
}
int main() {
int N; number D, V;
while(cin >> N >> D >> V && (N||D||V)) {
polygon g{};
rep(i, N) {
number x, y; cin >> x >> y;
g.push_back(point{x, y});
}
number ans = 0;
rep(i, N) {
number l = 0, h = 114514;
rep(_, 100) {
number mid = (l + h) / 2;
(compare(g, V, D, i, mid) ? l : h) = mid;
}
ans = max(ans, l);
}
printf("%.10f\n", ans);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
すべての数は６１７４に通ず
=============
0 から 9 の数字からなる四桁の数 N に対して以下の操作を行う。
1. N の桁それぞれの数値を大きい順に並べた結果得た数を L とする
2. N の桁それぞれの数値を小さい順に並べた結果得た数を S とする
3. 差 L-S を新しい N とする(1回分の操作終了)
4. 新しい N に対して 1. から繰り返す
このとき、全桁が同じ数字(0000, 1111など)である場合を除き、あらゆる四桁の数はいつかは 6174になることが知られている。例えば N = 2012の場合
1回目 (N = 2012): L = 2210, S = 0122, L-S = 2088
2回目 (N = 2088): L = 8820, S = 0288, L-S = 8532
3回目 (N = 8532): L = 8532, S = 2358, L-S = 6174
となり、3 回の操作で 6174 に到達する。
0 から 9 の数字からなる四桁の数が与えられたとき、何回の操作で 6174 に到達するか計算するプログラムを作成して下さい。
入力
--
入力は複数のデータセットからなる。入力の終わりは 0000 が１つの行で示される。各データセットは以下の形式で与えられる。
```
N
```
データセットは１行であり、N (1 ≤ N ≤ 9999) は四桁の数を示す。N < 1000 の場合は上の桁は 0 で埋められている。
データセットの数は 10000 を超えない。
出力
--
各データセットごとに何回の操作で 6174 に到達したかを１行に出力する。ただし全桁が同じ数字である数が入力として与えられた場合は NA と出力する。
入力例
---
```
6174
2012
3333
0000
```
出力例
---
```
0
3
NA
```
| #include <cstdio>
#include <sstream>
#include <string>
#include <algorithm>
using namespace std;
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
int main(){
int x, a, b;
string s;
while(scanf("%d", &x), x){
if(x % 1111 == 0){
puts("NA");
}
else{
int ans;
for(ans = 0; x != 6174; ++ans){
convert(x, s);
s.resize(4, '0');
sort(s.begin(), s.end());
convert(s, a);
reverse(s.begin(), s.end());
convert(s, b);
x = b - a;
}
printf("%d\n", ans);
}
}
} | #include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <climits>
using namespace std;
int ans[10010];
char tmp[8];
int dfs(int x){
if(ans[x] >= 0){
return ans[x];
}
if(ans[x] != -1){
return INT_MIN;
}
ans[x] = INT_MIN;
sprintf(tmp, "%04d", x);
sort(tmp, tmp + 4);
int b = strtol(tmp, 0, 10);
reverse(tmp, tmp + 4);
int a = strtol(tmp, 0, 10);
ans[x] = dfs(a - b) + 1;
return ans[x];
}
int main(){
for(int i = 0; i < 10005; ++i){
ans[i] = -1;
}
ans[6174] = 0;
int n;
while(scanf("%d", &n), n){
int a = dfs(n);
printf(a < 0 ? "NA\n" : "%d\n", a);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
パイプつなぎ職人の給料
===========
ぼくはパイプつなぎ職人です。パイプをつなぐジョイントとパイプさえもらえれば、どんなパイプだってつないでみせます。ぼくは毎日、親方からパイプとジョイントを渡されて、それをつないで親方に渡します。でも、パイプの数が多すぎるときは、１日でそれを全部つなげることはできません。そんなときでも親方はにっこり笑って、ぼくに給料を渡してくれます。
ところで、あるとき変なことに気がつきました。全部のパイプをつなげられたときより、つなげられなかったときの方が給料が多いことがしょっちゅうあるんです。あんまり変なので、ある日、親方が来たときに、給料の計算方法が書いてあるメモをこっそり見ちゃいました。そしたら、なんと
"給料は「パイプの本数×パイプの長さの総和」で支払う。ただし、ジョイントでつなげて、ひとつながりになったものは、それを１本のパイプとみなす。"
って書いてありました。これで全部つなげた方が給料が安くなることがある理由がわかりました。たとえば下図のように、長さ 1 のパイプ 3 本と長さ 2 のジョイント 2 本を全部つなげると長さ 1+2+1+2+1 = 7 のパイプが 1 本できるので、1 × (7) = 7 です。でも、ジョイントを一つだけ使って長さ 1+2+1 = 4のパイプと長さ 1 のパイプの 2 本にすると2 × (4+1) = 10なので、全部つなげるよりいっぱい給料がもらえます。
親方がなんでこんな方法で給料を決めてるかわからないけど、これでぼくもどうすればもらえる給料を多くできるかわかりました！
それでは、パイプの本数が与えられたとき、もらえる給料の最大の金額を計算するプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ１つの行で示される。各データセットは以下の形式で与えられる。
```
n
p1 ... pn
j1 ... jn-1
```
１行目にパイプの本数 n (2 ≤ n ≤ 65000) が与えられる。２行目は１つの空白で区切られた n 個の整数からなる。pi (1 ≤ pi ≤ 1000) はi番目のパイプの長さを示す。３行目は１つの空白で区切られた n-1 個の整数からなる。ji (1 ≤ ji ≤ 1000) は i 番目のジョイントの長さを示す。
i番目のジョイントは、i 番目と i+1 番目のパイプだけをつなげることができる。つなげたパイプの長さは、pi + ji + pi+1 になる。
データセットの数は 100 を超えない。
出力
--
各データセットごとに、得られる給料の最大の金額を1行に出力する。入力として与えられるデータセットでは、出力される値は必ず３２ビット符号無し整数の範囲に収まるものとする。
入力例1
----
```
3
1 1 1
3 3
4
3 3 3 3
1 1 1
5
1 2 3 4 5
4 3 2 1
0
```
出力例
---
```
12
48
76
```
| #include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int main(){
ll i,n,num,len,p,l[100000];
while(cin >> n,n){
num = n; len = 0;
for(i=0;i<n;i++){
cin >> p; len += p;
}
for(i=0;i<n-1;i++)cin >> l[i];
sort(l,l+n-1);
for(i=n-2;i>=0;i--){
if( (num-1)*(len+l[i]) < num*len )break;
num--; len += l[i];
}
cout << num*len << endl;
}
}
| #include<cstdio>
#include<algorithm>
using namespace std;
int main(){
int n,p,l[100000];
while(scanf("%d",&n),n){
long long num = n,len = 0;
for(int i=0;i<n;i++){ scanf("%d",&p); len += p;}
for(int i=0;i<n-1;i++)scanf("%d",&l[i]);
sort(l,l+n-1);
for(int i=n-2;i>=0;i--){
if( (num-1)*(len+l[i]) < num*len )break;
num--; len += l[i];
}
printf("%lld\n",num*len);
}
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
ビートパネル
======
遊太君は、近所のゲームセンターで人気のゲーム「ビートパネル」にはまっています。このゲームは図のようなグリッド状に並べられた 4×4 の計16個のパネル型のボタンからなります。
図のように、左上から右下にボタン1, ボタン2, …, ボタン16の順にボタンが並んでいます。ゲームでは一定間隔でビート音が鳴り最後に終了音が鳴ります。ビート音が鳴ると同時に複数のボタンが光ります。１個も光らない場合もあります。プレイヤーは、ビート音が鳴った直後から次の音が鳴るまでの間に両手の指を使って複数のボタンを１度だけ同時に押すことができます。何も押さないということも可能です。終了音が鳴ったと同時にゲームは終了します。
遊太君は c 通りの押し方を習得しており、ビート音が鳴る度に、それらの押し方の中から１つ決めてボタンを押します。押したボタンが光っていれば、それらのボタンの光は消え、消えたボタンの数がプレイヤーのスコアに加算されます。また、一度光ったボタンはそのボタンが押されるまで光は消えることはありません。
ビート音が n 回鳴るときのボタンの光り方と遊太君が習得している c 通りのボタンの押し方を入力とし、遊太君が獲得することのできる得点の最大値を出力するプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ２つの行で示される。各データセットは以下の形式で与えられる。
```
n c
a1,1 a1,2 ... a1,16
a2,1 a2,2 ... a2,16
...
an,1 an,2 ... an,16
b1,1 b1,2 ... b1,16
b2,1 b2,2 ... b2,16
...
bc,1 bc,2 ... bc,16
```
１行目は１つの空白で区切られた２つの整数からなる。n (1 ≤ n ≤ 30) はビート音の数、c (1 ≤ c ≤ 30) は習得しているボタンの押し方の数を示す。続く n＋c 行にボタンの光り方とボタンの押し方が与えられる。行中の入力項目の区切りは１つの空白である。ak,i は k 回目のビート音が鳴ったときのボタン i の光り方を、bj,i は c 通り中 j 番目の押し方でボタン i が押されるかどうかを表す。ak,iの値は 0 が「光らない」、1 が「光る」を表す。bj,i の値は 0 が「押さない」、1 が「押す」を表す。
データセットの数は 20 を超えない。
出力
--
各データセットごとに、得点の最大値を１行に出力する。
入力例
---
```
2 2
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
2 2
0 0 1 0 1 1 1 1 0 0 1 0 0 0 1 0
0 1 0 1 0 1 1 1 0 1 0 1 0 0 0 0
0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0
0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0
5 3
0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0
1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1
0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0
0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0
```
出力例
---
```
8
7
16
```
| #include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
using namespace std;
int**dp;
void func(int N,int C){
int beat[N][16],push[C][16];
int maximum = 0;
for(int i = 0; i < N; i++){
for(int k = 0; k < 16; k++)scanf("%d",&beat[i][k]);
}
for(int i = 0; i < C; i++){
for(int k = 0; k < 16; k++)scanf("%d",&push[i][k]);
}
int tmp,S,code;
int work[C][16];
S = 1;
code = 0;
for(int i = 0; i < 16; i++){
code += S*beat[0][i];
S *= 2;
}
dp[1][code] = 0;
for(int k = 0; k < C; k++){
tmp = 0;
for(int p = 0; p < 16; p++){
work[k][p] = beat[0][p];
if(work[k][p] == 1){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}
}
}
S = 1;
code = 0;
for(int i = 0; i < 16; i++){
code += S*work[k][i];
S *= 2;
}
dp[1][code] = max(dp[1][code],tmp);
maximum = max(maximum,dp[1][code]);
}
for(int i = 1; i < N; i++){
for(int state = 0; state < 65536; state++){
if(dp[i][state] != -1){
S = 1;
code = 0;
for(int loop = 0; loop < 16; loop++){
if(state & (1 << loop)){
code += S;
}else{
code += S*beat[i][loop];
}
S *= 2;
}
dp[i+1][code] = dp[i][state];
for(int k = 0; k < C; k++){
tmp = 0;
for(int p = 0; p < 16; p++){
if(state & (1 << p)){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}else{
work[k][p] = 1;
}
}else{
work[k][p] = beat[i][p];
if(work[k][p] == 1){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}
}
}
}
S = 1;
code = 0;
for(int a = 0; a < 16; a++){
code += S*work[k][a];
S *= 2;
}
dp[i+1][code] = max(dp[i+1][code],tmp+dp[i][state]);
}
}
}
}
for(int i = 0; i < 65536; i++)maximum = max(maximum,dp[N][i]);
printf("%d\n",maximum);
}
int main(){
int N,C;
dp = new int*[31];
for(int i = 0; i < 31; i++){
dp[i] = new int[65536];
}
while(true){
scanf("%d %d",&N,&C);
if(N == 0 && C == 0)break;
for(int i = 0; i <= N; i++){
for(int k = 0; k < 65536; k++)dp[i][k] = -1;
}
func(N,C);
}
return 0;
} | #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 30
#define SIZE 16
int N,C;
int POW[17];
int shine_table[NUM][SIZE],push_table[NUM][SIZE];
int shine_value[NUM+1],push_value[NUM];
int dp[2][65536];
void func(){
int sum;
for(int i = 0; i < N; i++){
sum = 0;
for(int k = 0; k < SIZE; k++){
scanf("%d",&shine_table[i][k]);
sum += shine_table[i][k]*POW[k];
}
shine_value[i] = sum;
}
shine_value[N] = POW[SIZE]-1;
for(int i = 0; i < C; i++){
sum = 0;
for(int k = 0; k < SIZE; k++){
scanf("%d",&push_table[i][k]);
sum += push_table[i][k]*POW[k];
}
push_value[i] = sum;
}
int CURRENT = 0,NEXT = 1;
for(int state = 0; state < POW[SIZE]; state++){
dp[CURRENT][state] = -1;
dp[NEXT][state] = -1;
}
dp[CURRENT][shine_value[0]] = 0;
int rest,next_state,add;
for(int i = 0; i < N; i++){
for(int state = 0; state < POW[SIZE]; state++){
if(dp[CURRENT][state] == -1)continue;
next_state = state|shine_value[i+1];
dp[NEXT][next_state] = max(dp[NEXT][next_state],dp[CURRENT][state]);
for(int k = 0; k < C; k++){
add = 0;
rest = 0;
for(int loop = 0; loop < SIZE; loop++){
if((state & (1 << loop))){
if(push_table[k][loop] == 1){
add++;
}else{
rest += POW[loop];
}
}
}
next_state = rest|shine_value[i+1];
dp[NEXT][next_state] = max(dp[NEXT][next_state],dp[CURRENT][state]+add);
}
}
for(int state = 0; state < POW[16]; state++){
dp[CURRENT][state] = -1;
}
swap(CURRENT,NEXT);
}
int ans = 0;
for(int state = 0; state < POW[SIZE]; state++)ans = max(ans,dp[CURRENT][state]);
printf("%d\n",ans);
}
int main(){
for(int i = 0; i < 17; i++)POW[i] = pow(2,i);
while(true){
scanf("%d %d",&N,&C);
if(N == 0 && C == 0)break;
func();
}
return 0;
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
モジュロ・クエリ
========
あなたに N 枚のカードを渡します。どのカードにも一つだけ自然数が書いてあります。ただし、同じ数が書いてあることはありません。
これから質問として、適当な自然数を言います。あなたが持っているカードに書いてある数を私が言った数で割ったときに得られる余りのうち最も大きなものを答えてください。
たとえば、あなたは 3 枚のカードを持っていて、それぞれ 9、3、8 と書いてあるとします。私が「4」と言ったら、9 と 3 と 8 をそれぞれ4 で割った余りを求めてください。余りはそれぞれ 1、3、0 ですが、この中でもっとも大きな余りは3 なので、3 が正しい答えになります。
では始めましょうか。え？ カードがいっぱいあるとたいへんだ？ しょうがないですね。それではコ
ンピュータを使って最大の余りを見つけることにしましょう。カードに書いてある数を、質問された数で割った余りのうち、最大のものを見つけるプログラムを作成してください。なお、質問は１回だけでなく何度もしますが、同じ数を 2 回以上質問することはありません。
入力
--
入力は１つのデータセットからなる。入力データは以下の形式で与えられる。
```
N Q
c1 c2 ... cN
q1
q2
:
qQ
```
１行目にカードの枚数 N (2 ≤ N ≤ 300000) と質問の回数 Q (2 ≤ Q ≤ 100000) が１つの空白区切りで与えられ、２行目にカードに書かれた数 ci (1 ≤ ci ≤ 300000) が１つの空白区切りで与えられる。続くQ 行に質問として与えられる数 qi (1 ≤ qi ≤ 300000) が与えられる。
出力
--
質問ごとに最大の余りを１行に出力する。
入力例
---
```
3 3
9 3 8
4
6
5
```
出力例
---
```
3
3
4
```
| #include <iostream>
#define C 300000
using namespace std;
int main() {
int n, q;
int c[300000], query[100000];
bool has_c[C+1];
cin >> n >> q;
for (int i=0; i<n; i++) {
cin >> c[i];
}
for (int i=0; i<q; i++) {
cin >> query[i];
}
for (int i=0; i<=C; i++) {
has_c[i] = false;
}
for (int i=0; i<n; i++) {
has_c[c[i]] = true;
}
for (int i=0; i<q; i++) {
int max_r = -1;
for (int r=query[i]-1; r>=0; r--) {
for (int k=0; true; k++) {
int x = k*query[i]+r;
if (x > C) {
break;
}
if (has_c[x]) {
max_r = max(r, max_r);
break;
}
}
if (max_r >= 0) {
break;
}
}
cout << max_r << endl;
}
return 0;
} | #include <cstdio>
#include <algorithm>
#define C 300000
using namespace std;
int main() {
int n, q;
int c[300000], query[100000];
bool has_c[C+1];
scanf("%d%d", &n, &q);
for (int i=0; i<n; i++) {
scanf("%d", &c[i]);
}
for (int i=0; i<q; i++) {
scanf("%d", &query[i]);
}
for (int i=0; i<=C; i++) {
has_c[i] = false;
}
for (int i=0; i<n; i++) {
has_c[c[i]] = true;
}
for (int i=0; i<q; i++) {
int max_r = -1;
for (int r=query[i]-1; r>=0; r--) {
for (int k=0; true; k++) {
int x = k*query[i]+r;
if (x > C) {
break;
}
if (has_c[x]) {
max_r = max(r, max_r);
break;
}
}
if (max_r >= 0) {
break;
}
}
printf("%d\n", max_r);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
イヅア国語辞典
=======
あなたはイヅア国の公用語であるイヅア語の国語辞典と、イヅア語のアルファベット（文字の一覧表）
を手に入れました。イヅア語のアルファベットにはN 種類の文字があります。イヅア語の国語辞典に現れる単語の順番は、イヅア語のアルファベット順に並んでいます。
辞典を見ると、載っているどの単語もN 文字で、しかも、N 種類の文字をひとつずつ含んでいることがわかりました。さらに調べてみると、辞典にはN 種類の文字の可能な並び方がすべて書かれていることを発見しました。
この発見から、あなたはある単語が辞典の何番目に出てくるかわかるようになりました。この知識を利用してイヅア国の人を驚かせてみましょう。まず、N 種類の文字をひとつずつアルファベット順に並べます。次に、任意の２文字の順番を入れ替える操作を R 回繰り返してもらいます。あなたは、出来上がった単語がイヅア国語辞典の何番目に出てくるか当てて見せます。そのための準備として、国語辞典中の単語の場所を求めるプログラムを作成してください。ただし、アルファベット順で最初の単語を 0 番目の単語とします。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ１つの行で示される。各データセットは以下の形式で与えられる。
```
N
R
s1 t1
s2 t2
:
sR tR
```
１行目にアルファベットを構成する文字の数 N (1 ≤ N ≤ 100000) が与えられ、２行目に文字を入れ替えてもらう回数 R (0 ≤ R ≤ 50) が与えられる。続く R 行に、入れ替えられる文字の位置の組が与えられる。si と ti (1 ≤ si < ti ≤ N) は、先頭から数えて si 番目と ti 番目の文字を i 回目に入れ替えることを表す。si と ti は１つの空白で区切られている。
データセットの数は100 を超えない。
出力
--
データセットごとに、入れ替えが終わった時点で得られた単語が国語辞典の何番目に現れるかを示す数を１行に出力する。ただし、出力すべき値は非常に大きくなりうるので、代わりに 1,000,000,007 で割った余りを出力する。
入力例
---
```
3
2
1 2
2 3
4
2
2 3
2 4
0
```
出力例
---
```
3
4
```
入出力例の最初のデータセットについて説明する。説明のため、アルファベットは小さい方から順番に、'A', 'B', 'C' の３文字からなるとする。これらの文字をアルファベット順に並べると "ABC" という文字列が得られる。この文字列の１番目の文字 'A' と２番目の文字 'B' を入れ替えると、"BAC" という文字列が得られる。次に、得られた文字列の２番目の文字 'A' と３番目の文字 'C' を入れ替えると、単語 "BCA" が得られる。辞典には、先頭から順に "ABC", "ACB", "BAC", "BCA", "CAB", "CBA" の６種類の単語が載っている。"BCA" はこの中で３番目（最初の"ABC"が０番目であることに注意）に現れるので、3 を 1,000,000,007 で割った余りである 3 が答えになる。
| #include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
const int N_MAX = 100000;
const int R_MAX = 50;
const int BigNumber = 1000000007;
long long *Factrial;
const int smallNMax = N_MAX ;
struct squaence{
int start,length, counter;
squaence(){}
squaence(int _start, int _end){
start = _start;
length = _end - _start + 1;
counter = 0;
}
};
void SolveForLargeN(int N, int R){
int s[R_MAX], t[R_MAX];
vector<int> st_vector(2*R);
for(int r=0; r<R; r++){
int tmp_s, tmp_t;
cin >> tmp_s >> tmp_t;
s[r] = tmp_s-1;
t[r] = tmp_t-1;
st_vector[2*r ] = s[r];
st_vector[2*r+1] = t[r];
}
sort(st_vector.begin(), st_vector.end());
st_vector.erase(unique(st_vector.begin(), st_vector.end()), st_vector.end());
const int st_vector_size = st_vector.size();
vector<squaence> number(st_vector.size()*2+1);
int n=0;
for(int j=0; j<st_vector_size; j++){
if(n <st_vector[j])number.push_back(squaence(n, st_vector[j]-1));
n = st_vector[j];
number.push_back(squaence(n, n));
n++;
}
if(n<N)number.push_back(squaence(n, N-1));
map<int,int> index_map;
for(int i=0; i<st_vector_size; i++){
int v = st_vector[i];
auto it = find_if(number.begin(), number.end(), [v](squaence s){return s.start==v;});
index_map[v] = distance(number.begin(), it) ;
}
for(int r=0; r<R; r++){
int rs = index_map[s[r]];
int rt = index_map[t[r]];
int ns = number[rs].start;
int nt = number[rt].start;
int cs = number[rs].counter;
int ct = number[rt].counter;
if(ns<nt) ct++;
else cs--;
for(int i=rs+1; i<rt; i++){
int ni = number[i].start;
if(ni < nt){
ct+=number[i].length;
if(ns<ni) number[i].counter++;
}
if(ni < ns){
cs-=number[i].length;
if(nt<ni) number[i].counter--;
}
}
number[rs].counter = cs;
number[rt].counter = ct;
swap(number[rs], number[rt]);
}
n=0;
long long index = 0;
const int number_size = number.size();
for(int i=0; i<number_size; i++){
const squaence* s = &number[number_size-1-i];
if(s->counter != 0){
long long f = 0;
for(int j=0; j< s->length; j++,n++){
f += Factrial[n] % BigNumber;
}
index += s->counter * f % BigNumber;
}
else{
n += s->length;
}
}
cout << index%BigNumber << endl;
}
void SolveForSmallN(int N, int R){
long long RevFactrial[smallNMax];
int number[smallNMax], counter[smallNMax];
RevFactrial[smallNMax-1] = 1;
for(int i=smallNMax-2; i>=0; i--){
RevFactrial[i] = (RevFactrial[i+1] * (smallNMax -i-1)) % BigNumber;
}
for(int n=0; n<N; n++){
number[n] = n;
counter[n] = 0;
}
for(int r=0; r<R; r++){
int s, t;
cin >> s >> t;
s--; t--;
int ns = number[s];
int nt = number[t];
int cs = counter[t];
int ct = counter[s];
if(ns<nt) cs++;
else ct--;
for(int i=s+1; i<t; i++){
int ni = number[i];
if(ni < nt){
cs++;
if(ns<ni) counter[i]++;
}
if(ni < ns){
ct--;
if(nt<ni) counter[i]--;
}
}
counter[s] = cs;
counter[t] = ct;
number[s] = nt;
number[t] = ns;
}
long long index = 0;
for(int i=0; i<N-1; i++){
index += counter[i]*RevFactrial[smallNMax-N+i]%BigNumber;
}
cout << index%BigNumber << endl;
}
int main(){
Factrial = new long long[N_MAX];
Factrial[0] = 1;
for(int i=1; i<N_MAX; i++){
Factrial[i] = (Factrial[i-1] * i) % BigNumber;
}
int N,R;
while(true){
cin >> N;
if(N==0) break;
cin >> R;
if(N>smallNMax) SolveForLargeN(N,R);
else SolveForSmallN(N,R);
}
delete[] Factrial;
return 0;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
const int N_MAX = 100000;
const int R_MAX = 50;
const int BigNumber = 1000000007;
struct squaence{
int start,length, counter;
squaence(){}
squaence(int _start, int _end){
start = _start;
length = _end - _start + 1;
counter = 0;
}
};
int main(){
int s[R_MAX], t[R_MAX];
int N,R;
long long Factrial[N_MAX];
Factrial[0] = 1;
for(int i=1; i<N_MAX; i++){
Factrial[i] = (Factrial[i-1] * i) % BigNumber;
}
while(true){
cin >> N;
if(N==0) break;
cin >> R;
vector<int> st_vector(2*R);
for(int r=0; r<R; r++){
int tmp_s, tmp_t;
cin >> tmp_s >> tmp_t;
s[r] = tmp_s-1;
t[r] = tmp_t-1;
st_vector[2*r ] = s[r];
st_vector[2*r+1] = t[r];
}
sort(st_vector.begin(), st_vector.end());
st_vector.erase(unique(st_vector.begin(), st_vector.end()), st_vector.end());
const int st_vector_size = st_vector.size();
vector<squaence> number;//(st_vector.size()*2+1);
int n=0;
for(int j=0; j<st_vector_size; j++){
if(n <st_vector[j])number.push_back(squaence(n, st_vector[j]-1));
n = st_vector[j];
number.push_back(squaence(n, n));
n++;
}
if(n<N)number.push_back(squaence(n, N-1));
map<int,int> index_map;
for(int i=0; i<st_vector_size; i++){
int v = st_vector[i];
auto it = find_if(number.begin(), number.end(), [v](squaence s){return s.start==v;});
index_map[v] = distance(number.begin(), it) ;
}
for(int r=0; r<R; r++){
int rs = index_map[s[r]];
int rt = index_map[t[r]];
int ns = number[rs].start;
int nt = number[rt].start;
int cs = number[rs].counter;
int ct = number[rt].counter;
if(ns<nt) ct++;
else cs--;
for(int i=rs+1; i<rt; i++){
int ni = number[i].start;
if(ni < nt){
ct+=number[i].length;
if(ns<ni) number[i].counter++;
}
if(ni < ns){
cs-=number[i].length;
if(nt<ni) number[i].counter--;
}
}
number[rs].counter = cs;
number[rt].counter = ct;
swap(number[rs], number[rt]);
}
n=0;
long long index = 0;
const int number_size = number.size();
for(int i=0; i<number_size; i++){
const squaence* s = &number[number_size-1-i];
if(s->counter != 0){
long long f = 0;
for(int j=0; j< s->length; j++,n++){
f += Factrial[n];
}
index += s->counter * f % BigNumber;
}
else{
n += s->length;
}
}
cout << index%BigNumber << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
イヅア国語辞典
=======
あなたはイヅア国の公用語であるイヅア語の国語辞典と、イヅア語のアルファベット（文字の一覧表）
を手に入れました。イヅア語のアルファベットにはN 種類の文字があります。イヅア語の国語辞典に現れる単語の順番は、イヅア語のアルファベット順に並んでいます。
辞典を見ると、載っているどの単語もN 文字で、しかも、N 種類の文字をひとつずつ含んでいることがわかりました。さらに調べてみると、辞典にはN 種類の文字の可能な並び方がすべて書かれていることを発見しました。
この発見から、あなたはある単語が辞典の何番目に出てくるかわかるようになりました。この知識を利用してイヅア国の人を驚かせてみましょう。まず、N 種類の文字をひとつずつアルファベット順に並べます。次に、任意の２文字の順番を入れ替える操作を R 回繰り返してもらいます。あなたは、出来上がった単語がイヅア国語辞典の何番目に出てくるか当てて見せます。そのための準備として、国語辞典中の単語の場所を求めるプログラムを作成してください。ただし、アルファベット順で最初の単語を 0 番目の単語とします。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ１つの行で示される。各データセットは以下の形式で与えられる。
```
N
R
s1 t1
s2 t2
:
sR tR
```
１行目にアルファベットを構成する文字の数 N (1 ≤ N ≤ 100000) が与えられ、２行目に文字を入れ替えてもらう回数 R (0 ≤ R ≤ 50) が与えられる。続く R 行に、入れ替えられる文字の位置の組が与えられる。si と ti (1 ≤ si < ti ≤ N) は、先頭から数えて si 番目と ti 番目の文字を i 回目に入れ替えることを表す。si と ti は１つの空白で区切られている。
データセットの数は100 を超えない。
出力
--
データセットごとに、入れ替えが終わった時点で得られた単語が国語辞典の何番目に現れるかを示す数を１行に出力する。ただし、出力すべき値は非常に大きくなりうるので、代わりに 1,000,000,007 で割った余りを出力する。
入力例
---
```
3
2
1 2
2 3
4
2
2 3
2 4
0
```
出力例
---
```
3
4
```
入出力例の最初のデータセットについて説明する。説明のため、アルファベットは小さい方から順番に、'A', 'B', 'C' の３文字からなるとする。これらの文字をアルファベット順に並べると "ABC" という文字列が得られる。この文字列の１番目の文字 'A' と２番目の文字 'B' を入れ替えると、"BAC" という文字列が得られる。次に、得られた文字列の２番目の文字 'A' と３番目の文字 'C' を入れ替えると、単語 "BCA" が得られる。辞典には、先頭から順に "ABC", "ACB", "BAC", "BCA", "CAB", "CBA" の６種類の単語が載っている。"BCA" はこの中で３番目（最初の"ABC"が０番目であることに注意）に現れるので、3 を 1,000,000,007 で割った余りである 3 が答えになる。
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MAX_N 100005
ll mod=1e9+7;
ll mul(ll a,ll b){
return (a*b)%mod;
}
int bit[MAX_N];
void add(int i,int x){
i++;
while(i<MAX_N){
bit[i]+=x;
i+=(i&-i);
}
}
int sum(int i){
i++;
int res=0;
while(i){
res+=bit[i];
i-=(i&-i);
}
return res;
}
ll N,R,a,b;
ll fact[MAX_N];
int t[MAX_N];
int main(){
fact[0]=1;
for(int i=1;i<MAX_N;i++)
fact[i]=mul(fact[i-1],i);
while(1){
scanf("%lld",&N);
if(N==0)break;
scanf("%lld",&R);
memset(bit,0,sizeof(bit));
for(int i=0;i<N;i++)t[i]=i;
for(int i=0;i<R;i++){
scanf("%lld %lld",&a,&b);
a--,b--;
swap(t[a],t[b]);
}
ll ans=0;
for(int i=0;i<N;i++){
ll num=t[i];
ll cnt=num-sum(num);
ans+= mul(fact[N-1-i],cnt);
ans%=mod;
add(t[i],1);
}
printf("%lld\n",ans);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
struct BIT{
vector<int> bit;
int n;
BIT(){init();}
BIT(int n):n(n){init();}
void init(){
bit.clear();
bit.resize(n+1,0);
}
int sum(int i){
int s=0;
while(i>0){
s+=bit[i];
i-=i&-i;
}
return s;
}
void add(int i,int x){
while(i<=n){
bit[i]+=x;
i+=i&-i;
}
}
};
int MOD=1000000007LL;
int s[114514],t[114514];
int fact[114514];
void init(int mod){
fact[0]=fact[1]=1;
for(int i=2;i<114514;i++)
fact[i]=(fact[i-1]*i)%MOD;
}
signed main(){
int n;
init(MOD);
while(cin>>n,n){
BIT bit(n);
for(int i=0;i<n;i++) s[i]=i+1;
int r;
cin>>r;
for(int i=0;i<r;i++){
int a,b;
cin>>a>>b;
a--;b--;
swap(s[a],s[b]);
}
for(int i=n-1;i>=0;i--){
t[i]=bit.sum(s[i]);
bit.add(s[i],1);
}
int ans=0;
for(int i=0;i<n;i++){
(ans+=t[i]*fact[n-1-i])%=MOD;
}
cout<<ans<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
図画工作
====
イヅア大学附属小学校は日本有数の競技プログラマー養成校として有名です。この学校の教員は幅広い
アルゴリズムの知識を持ち、日々それを活用しています。教員であるあなたは、今年は図画工作の授業
を担当することになりました。この授業では、児童全員がそれぞれ１年間で一つの課題を完成させることになっています。授業の概要は以下のとおりです。
* １年間で授業は D 回（同じ日に2 回以上授業はない）あり、その全てが課題制作に充てられる。
* 制作する課題は M 種類用意されている。
* それぞれの児童に、M 種類の中から課題を１つずつ割り当てる。
* 児童は N 人であり、N 人それぞれに異なる課題が割り当てられる。
児童は、K 種類ある部品のうちいくつかの種類の部品を使用して課題を完成させます。課題の制作の概要は以下のとおりです。
* 課題ごとに、使用すべき部品の種類と数はあらかじめ決められている。
* 課題が完成するまでに使用する部品の種類と数は、その課題で使用すべき部品の種類と数に、過不足なく一致していなければならない。
* 異なる課題でも、使われる部品の種類と数がすべて同じ場合もある。
* どの課題も、同じ種類の部品は２個までしか使用できない。
* 部品を使用する順序は課題の完成に影響を与えない。
* いくつかの部品が入っている袋が事前に P 個用意されている。ただし、異なる袋でも、入っている部品の種類と数がすべて同じ場合もある。
* 教員は、児童１人につき袋を１つだけ渡すことができる（袋を渡さない児童がいてもよい）。
* ２人以上の児童に同じ袋を渡すことはできない（反対に、誰にも渡されない袋があってもよい）。
* 袋を渡された児童は、袋の中に入っている部品をすべて、自分が制作する課題に使わなければならない。
袋に入っている部品以外で課題に使用する部品は、別途購入する必要があります。部品の購入に関する条件は以下のとおりです。
* 部品は授業の日だけ購入でき、その日にしか使えない。
* それぞれの課題について、１回の授業でＬ個までの部品を購入することができる。
* 部品の種類によって価格が設定されており、購入する日によって価格が変動する。ただし、どの種類も品切れになることはない。
あなたは、このような条件下で、授業にかかる経費をなるべく抑えたいと考えています。そこで、児童全員の部品購入費の合計の最小値を計算するプログラムを作成することにしました。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ３つの行で示される。各データセットは以下の形式で与えられる。
```
D K L
c1,1 c1,2 ... c1,K
c2,1 c2,2 ... c2,K
:
cD,1 cD,2 ... cD,K
M N P
r1,1 r1,2 ... r1,K
r2,1 r2,2 ... r2,K
:
rM,1 rM,2 ... rM,K
t1,1 t1,2 ... t1,K
t2,1 t2,2 ... t2,K
:
tP,1 tP,2 ... tP,K
```
各行で与えられる数値は１つの空白で区切られている。
D（1 ≤ D ≤ 8）は授業の回数、K（1 ≤ K ≤ 8）は部品の種類の数、L（1 ≤ L ≤ 8）は１日に購入することができる部品の数を示す。cd,k （1 ≤ cd,k ≤ 100）は d 日目の部品k の価格を示す。
M（1 ≤ M ≤ 200）は課題の種類の数、N（1 ≤ N ≤ M）は生徒の人数、P（1 ≤ P ≤ 200）は袋の数を示す。
rm,k （0 ≤ rm,k ≤ 2）は課題 m に必要な部品 k の個数、tp,k （0 ≤ tp,k ≤ 2）は袋 p に入っている部品 k の個数を示す。
部品を１つも必要としない課題や、空の袋は与えられないものとする。
データセットの数は20 を超えない。
出力
--
データセットごとに、生徒全員の部品購入費の合計の最小値を１行に出力する。Ｎ種類の作品を完成させることができない場合は -1 を出力する。
入力例
---
```
2 2 1
5 3
2 2
3 3 1
2 0
1 2
2 2
1 1
2 2 1
5 3
2 2
3 2 1
2 0
1 2
2 2
1 1
2 2 2
5 3
2 2
3 2 1
2 0
1 2
2 2
1 1
4 3 1
2 2 1
3 2 2
2 3 3
1 2 2
5 4 3
1 1 0
1 0 1
1 0 2
1 1 2
2 2 2
1 0 1
2 0 2
1 1 1
0 0 0
```
出力例
---
```
-1
9
6
7
```
| #include<bits/stdc++.h>
using namespace std;
const int INF=1001001001;
const int MAX_V=1000;
const int S=MAX_V-2,T=MAX_V-1;
struct edge{
int to,cap,cost,rev;
edge(int to,int cap,int cost,int rev)
:to(to),cap(cap),cost(cost),rev(rev){}
};
vector<edge>G[MAX_V];
int dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];
void add_edge(int from,int to,int cap,int cost){
G[from].push_back(edge(to,cap,cost,G[to].size()));
G[to].push_back(edge(from,0,-cost,G[from].size()-1));
}
int min_cost_flow(int s,int t,int f){
int res=0;
while(f>0){
fill_n(dist,MAX_V,INF);
dist[s]=0;
bool update=true;
while(update){
update=false;
for(int v=0;v<MAX_V;v++){
if(dist[v]==INF)continue;
for(int i=0;i<G[v].size();i++){
edge &e=G[v][i];
if(e.cap>0&&dist[e.to]>dist[v]+e.cost){
dist[e.to]=dist[v]+e.cost;
prevv[e.to]=v;
preve[e.to]=i;
update=true;
}
}
}
}
if(dist[t]==INF)return -1;
int d=f;
for(int v=t;v!=s;v=prevv[v]){
edge &e=G[prevv[v]][preve[v]];
d=min(d,e.cap);
}
f-=d;
res+=dist[t]*d;
for(int v=t;v!=s;v=prevv[v]){
edge &e=G[prevv[v]][preve[v]];
e.cap-=d;
G[v][e.rev].cap+=d;
}
}
return res;
}
int D,K,L;
int M,N,P;
int c[8][8],r[200],t[200];
int cost[1<<16];
int dp[9][1<<16];
void DPing(){
fill_n(*dp,9*(1<<16),INF);
dp[0][0]=0;
for(int i=0;i<D;i++){
for(int j=0;j<L;j++){
for(int k=0;k<(1<<(2*K));k++){
for(int l=0;l<K;l++){
if((k>>(2*l)&3)>=2)continue;
dp[j+1][k+(1<<(2*l))]=min(dp[j+1][k+(1<<(2*l))],dp[j][k]+c[i][l]);
}
}
}
for(int j=0;j<(1<<(2*K));j++){
for(int k=1;k<=L;k++){
dp[0][j]=min(dp[0][j],dp[k][j]);
dp[k][j]=INF;
}
}
}
for(int i=0;i<(1<<(2*K));i++){
cost[i]=dp[0][i];
}
}
bool in(int a,int b){
for(int i=0;i<K;i++){
int va=a>>(i*2)&3;
int vb=b>>(i*2)&3;
if(va>vb)return false;
}
return true;
}
void solve(){
DPing();
fill_n(G,MAX_V,vector<edge>());
for(int i=0;i<M;i++)add_edge(S,i,1,0);
for(int i=0;i<P;i++)add_edge(M+i,T,1,0);
for(int i=0;i<M;i++){
if(cost[r[i]]!=INF)add_edge(i,T,1,cost[r[i]]);
for(int j=0;j<P;j++){
if(in(t[j],r[i])&&cost[r[i]-t[j]]!=INF){
add_edge(i,M+j,1,cost[r[i]-t[j]]);
}
}
}
cout<<min_cost_flow(S,T,N)<<endl;
}
int get(){
int ret=0;
for(int i=0;i<K;i++){
int v;cin>>v;
ret+=v<<(i*2);
}
return ret;
}
int main(){
while(cin>>D>>K>>L,D||K||L){
for(int i=0;i<D;i++)for(int j=0;j<K;j++)cin>>c[i][j];
cin>>M>>N>>P;
for(int i=0;i<M;i++)r[i]=get();
for(int i=0;i<P;i++)t[i]=get();
solve();
}
return 0;
} | #include<cstdio>
#include<vector>
#include<algorithm>
#include<iostream>
#include<cassert>
#include<cstring>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<string>
#include<climits>
using namespace std;
typedef pair<int,int>pint;
typedef vector<int>vint;
#define pb push_back
#define mp make_pair
#define rep(i,n) for(int i=0;i<(n);i++)
template<class T,class U>void chmin(T &t,U f){if(t>f)t=f;}
template<class T,class U>void chmax(T &t,U f){if(t<f)t=f;}
const int INF=1001001001;
int D,K,L;
int c[8][8];
int M,N,P;
int r[200];
int t[200];
int dp[1<<16];
void dping(){
fill_n(dp,1<<16,INF);
dp[0]=0;
rep(i,D)rep(latte,L){
for(int j=(1<<(2*K))-1;j>=0;j--){
rep(k,K){
if((j>>(2*k)&3)>=2)continue;
chmin(dp[j+(1<<(2*k))],dp[j]+c[i][k]);
}
}
}
}
struct edge{
int to,cap,cost,rev;
edge(int to,int cap,int cost,int rev):to(to),cap(cap),cost(cost),rev(rev){}
};
const int MAX_V=500;
int S=MAX_V-2,T=MAX_V-1;
int V;
vector<edge>G[MAX_V];
int dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];
void add_edge(int from,int to,int cap,int cost){
G[from].pb(edge(to,cap,cost,G[to].size()));
G[to].pb(edge(from,0,-cost,G[from].size()-1));
}
int min_cost_flow(int s,int t,int f){
int res=0;
while(f>0){
fill_n(dist,MAX_V,INF);
dist[s]=0;
bool update=true;
while(update){
update=false;
rep(v,MAX_V){
if(dist[v]==INF)continue;
rep(i,G[v].size()){
edge &e=G[v][i];
if(e.cap>0&&dist[e.to]>dist[v]+e.cost){
dist[e.to]=dist[v]+e.cost;
prevv[e.to]=v;
preve[e.to]=i;
update=true;
}
}
}
}
if(dist[t]==INF)return -1;
int d=f;
for(int v=t;v!=s;v=prevv[v]){
chmin(d,G[prevv[v]][preve[v]].cap);
}
f-=d;
res+=d*dist[t];
for(int v=t;v!=s;v=prevv[v]){
edge &e=G[prevv[v]][preve[v]];
e.cap-=d;
G[v][e.rev].cap+=d;
}
}
return res;
}
int main(){
while(cin>>D>>K>>L,D||K||L){
memset(r,0,sizeof(r));memset(t,0,sizeof(t));
rep(i,MAX_V)G[i].clear();
rep(i,D)rep(j,K)cin>>c[i][j];
cin>>M>>N>>P;
rep(i,M){
rep(j,K){
int a;cin>>a;
r[i]|=a<<(j*2);
}
}
rep(i,P){
rep(j,K){
int a;cin>>a;
t[i]|=a<<(j*2);
}
}
dping();
rep(i,M){
add_edge(S,i,1,0);
if(r[i]!=INF)add_edge(i,T,1,dp[r[i]]);
}
rep(i,P){
add_edge(M+i,T,1,0);
}
rep(i,M){
rep(j,P){
bool ok=true;
rep(k,K)if((r[i]>>(2*k)&3)<(t[j]>>(2*k)&3))ok=false;
if(ok)add_edge(i,M+j,1,dp[r[i]-t[j]]);
}
}
cout<<min_cost_flow(S,T,N)<<endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
おそろいの景品
=======
ジョウ君とヤエさんは仲の良いカップルです。ジョウ君はカプセル玩具自販機(ガチャポン)の景品を集めており、二人で出かけたときも、ガチャポンを見つけると何度かやってみるほどの熱の入りようです。ヤエさんは楽しそうなジョウ君をそばで見ているだけでしたが、ジョウ君の今度の誕生日プレゼントにガチャポンの景品をひとつあげることにしました。ヤエさんはガチャポン自体にはあまり興味がわきませんでしたが、できればジョウ君とおそろいの景品が欲しいと思っています。
ヤエさんがやってみようと思うガチャポンは、１回のチャレンジで景品がひとつ出ます。品切れのものも含め景品が何種類あるのかと、それぞれの景品がいくつ残っているのかはわかります。しかし、1回のチャレンジでどの景品が出るかはわかりません。そこで、景品が出る順番にかかわらず、ヤエさんが同じ景品を必ず２つ得るために最低限必要なチャレンジの回数を出力するプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ1つの行で示される。各データセットは以下の形式で与えられる。
```
N
k1 k2 ... kN
```
各データセットは2行であり、1行目に景品が何種類あるかを表す整数N(1 ≤ N ≤ 10000)が与えられる。続く1行に各景品がいくつ残っているのかを表す整数ki(0 ≤ ki ≤ 10000)が与えられる。
データセットの数は100を超えない。
出力
--
データセットごとに、同じ景品を必ず２つ得るために最低限必要なチャレンジの回数を出力する。ただし、不可能な場合はNAと出力する。
入力例
---
```
2
3 2
3
0 1 1
1
1000
0
```
出力例
---
```
3
NA
2
```
１つ目のデータセットでは、運良く１種類目か２種類目の景品が連続で出て２回で済む可能性はあるが、同じ種類の景品を必ず２つ得るためには３回チャレンジする必要がある。
２つ目のデータセットでは、２つ以上残っている景品がもともと無いので不可能である。
３つ目のデータセットでは、景品は１種類だけなので２回のチャレンジでその景品が必ず２つ得られる。
| #include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int N;
vector<int> data;
while (1){
data.clear();
scanf("%d", &N);
if (N == 0)break;
for (int i = 0; i < N; i++){
int temp;
scanf("%d", &temp);
data.push_back(temp);
}
bool flag = false;
for (int i = 0; i < N; i++){
if (data[i] > 1){
flag = true;
break;
}
}
if (!flag){
printf("NA\n");
}
else{
if(N == 1)
printf("2\n");
else{
int ans = 1;
for (int i = 0; i < N; i++){
if (data[i] != 0 )ans++;
}
printf("%d\n", ans);
}
}
}
return 0;
} | #include <cstdio>
#include <vector>
#include <algorithm>
int N;
int main(){
while(1){
start:
scanf("%d",&N);
if(N == 0)break;
int cnt = 0;
bool flag = false;
for(int i=0;i<N;i++){
int tmp;
scanf("%d",&tmp);
if(tmp != 0)cnt++;
if(tmp > 1) flag = true;
}
if(N == 1 && flag){
printf("2\n");
goto start;
}
if(!flag){
printf("NA\n");
goto start;
}
int ans = cnt + 1;
printf("%d\n",ans);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
おそろいの景品
=======
ジョウ君とヤエさんは仲の良いカップルです。ジョウ君はカプセル玩具自販機(ガチャポン)の景品を集めており、二人で出かけたときも、ガチャポンを見つけると何度かやってみるほどの熱の入りようです。ヤエさんは楽しそうなジョウ君をそばで見ているだけでしたが、ジョウ君の今度の誕生日プレゼントにガチャポンの景品をひとつあげることにしました。ヤエさんはガチャポン自体にはあまり興味がわきませんでしたが、できればジョウ君とおそろいの景品が欲しいと思っています。
ヤエさんがやってみようと思うガチャポンは、１回のチャレンジで景品がひとつ出ます。品切れのものも含め景品が何種類あるのかと、それぞれの景品がいくつ残っているのかはわかります。しかし、1回のチャレンジでどの景品が出るかはわかりません。そこで、景品が出る順番にかかわらず、ヤエさんが同じ景品を必ず２つ得るために最低限必要なチャレンジの回数を出力するプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ1つの行で示される。各データセットは以下の形式で与えられる。
```
N
k1 k2 ... kN
```
各データセットは2行であり、1行目に景品が何種類あるかを表す整数N(1 ≤ N ≤ 10000)が与えられる。続く1行に各景品がいくつ残っているのかを表す整数ki(0 ≤ ki ≤ 10000)が与えられる。
データセットの数は100を超えない。
出力
--
データセットごとに、同じ景品を必ず２つ得るために最低限必要なチャレンジの回数を出力する。ただし、不可能な場合はNAと出力する。
入力例
---
```
2
3 2
3
0 1 1
1
1000
0
```
出力例
---
```
3
NA
2
```
１つ目のデータセットでは、運良く１種類目か２種類目の景品が連続で出て２回で済む可能性はあるが、同じ種類の景品を必ず２つ得るためには３回チャレンジする必要がある。
２つ目のデータセットでは、２つ以上残っている景品がもともと無いので不可能である。
３つ目のデータセットでは、景品は１種類だけなので２回のチャレンジでその景品が必ず２つ得られる。
| #include<stdio.h>
int main(void)
{
int N,i,c;
int *k,*kk;
while(1){
scanf("%d",&N);
if(N==0) break;
k = new int [N];
kk = new int [N];
for(i=0;i<N;i++)
kk[i] = 0;
for(i=0;i<N;i++)
scanf("%d",&k[i]);
i=0,c=0;
while(1){
if(k[i%N] > 0){
k[i%N]--;
kk[i%N]++;
c++;
}
if(kk[i%N] == 2){
printf("%d\n",c);
break;
}
if(i > N * 2){
printf("NA\n");
break;
}
i++;
}
}
return 0;
} | #include <stdio.h>
int k[10000];
int main()
{
int N, cnt, same, Not;
while( 1 ) {
cnt = 0;
same = 0;
Not = 0;
for( int i = 0; i < 10000; i++ ) k[i] = 0;
scanf( "%d", &N );
if( N == 0 ) break;
for( int i = 0; i < N; i++ ) {
scanf( "%d", &k[i] );
if( k[i] > 1 ) same++;
else if( k[i] == 0 ) Not++;
}
if( N == 1 && k[0] >= 2 ) {
printf( "2\n" );
continue;
}
else if( same == 0 ) {
printf( "NA\n" );
continue;
}
printf( "%d\n", N + 1 - Not );
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
陣形
==
プログラマー養成校であるアカベ高校では、チーム戦の競技プログラマーの役割を以下の３タイプに分けています。
| Ｃ： | コーダー | 言語を熟知しており、コーディングを行う。 |
| --- | --- | --- |
| Ａ： | アルゴリズマー | 論理的思考が得意であり、アルゴリズムを考える。 |
| Ｎ： | ナビゲーター | 読解力に長けており、問題の分析・デバッグをする。 |
この高校では以下のいずれかの陣形で３人一組のチームを構成しています。
| ＣＣＡ： | バランスがとれている安定型 |
| --- | --- |
| ＣＣＣ： | スピードを見込めるがリスクの高い速攻型 |
| ＣＡＮ： | 正確に問題を解く慎重型 |
| #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[64][64][64];
int dfs(int c, int a, int n){
if(dp[c][a][n] >= 0) return dp[c][a][n];
int res = 0;
if(c > 0 && a > 0 && n > 0) res = max(res, dfs(c-1, a-1, n-1)+1);
if(c > 1 && a > 0) res = max(res, dfs(c-2, a-1, n)+1);
if(c > 2) res = max(res, dfs(c-3, a, n)+1);
return dp[c][a][n] = res;
}
int main(){
cin >> Q;
rep(i, Q){
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while(c > 8 && a > 4 && n > 0){
res++;
c--;
a--;
n--;
}
while(c > 8 && a > 4){
res++;
c-=2;
a--;
}
while(c > 8){
res++;
c-=3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[64][64][32];
int dfs(int c, int a, int n){
if(dp[c][a][n] >= 0) return dp[c][a][n];
int res = 0;
if(c > 0 && a > 0 && n > 0) res = max(res, dfs(c-1, a-1, n-1)+1);
if(c > 1 && a > 0) res = max(res, dfs(c-2, a-1, n)+1);
if(c > 2) res = max(res, dfs(c-3, a, n)+1);
return dp[c][a][n] = res;
}
int main(){
cin >> Q;
rep(i, Q){
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while(c > 8 && a > 4 && n > 0){
res++;
c--;
a--;
n--;
}
while(c > 8 && a > 4){
res++;
c-=2;
a--;
}
while(c > 8){
res++;
c-=3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
勉強会
===
プログラマー養成校のアカベ高校には、生徒自身で運営するユニークな勉強会があります。プログラマーは新しい技術を常に取り入れることが大切なので、この勉強会を通して自学自習の習慣を身につけることがこの活動のねらいです。
生徒は全部でN人おり、それぞれが入学時のプログラミングコンテストの結果で得られたスコアを持っています。勉強会ではN人の生徒のうち何人かがリーダーになり、各リーダーがそれぞれのグループを運営するとともに、自らの運営するグループに参加します。
リーダー以外の生徒は、自分のスコアよりも低いスコアのリーダーが運営するグループには参加できません。また、0以上のある値rを１つ決め、グループに参加する生徒とリーダーのスコアの差がr以内となるようにしています。つまり、グループのリーダーのスコアがsのとき、自分のスコアがsを超えているか、あるいは s - r 未満ならば、そのグループには参加できません。
あなたは勉強会の実行委員長であり、運営準備のためにシミュレーションを行うことにしました。シミュレーションでは、リーダーが誰もいない状態から始め、以下の操作を何回か繰り返します。
* 生徒をリーダーに加える。
* 生徒をリーダーから外す。
* 要求時点でのリーダーの組み合わせについて、どのグループにも参加できない生徒がx人以下になるような、最小のrを求める。
このようなシミュレーションを行うプログラムを作成してください。
入力
--
入力は1つのデータセットからなる。入力は以下の形式で与えられる。
```
N Q
s1
s2
:
sN
QUERY1
QUERY2
:
QUERYQ
```
1行目に生徒の数N(1 ≤ N ≤ 1000000)、処理要求の数Q(0 ≤ Q ≤ 1000)が与えられる。
続くN行にi番目の生徒のスコアを示す整数si(0 ≤ si ≤ 1,000,000,000)が与えられる。生徒は1,2,...,N で番号付けされているものとする。
続くQ行に処理要求QUERYiが与えられる。処理要求は時系列順に与えられる。処理要求はADD, REMOVE, CHECKの3種類あり、各QUERYiは以下のいずれかの形式で与えられる。
```
ADD a
```
または
```
REMOVE a
```
または
```
CHECK x
```
ADD aは番号a(1 ≤ a ≤ N)の生徒をリーダーに加えることを表す。
REMOVE aは番号a(1 ≤ a ≤ N)の生徒をリーダーから外すことを表す。
CHECK xは出力要求を表す。どのグループにも参加できない生徒の数の上限x(0 ≤ x ≤ N)が与えられる。
なお、入力は以下の条件を満たすものとする。
* どの時点でも、リーダーの人数が100人を超えることはない。
* その時点でリーダーである生徒をリーダーに加えることはない。
* その時点でリーダーでない生徒をリーダーから外すことはない。
出力
--
時系列順に各出力要求の時点で、どのグループにも参加できない生徒がx人以下になるような最小のrを1行に出力する。ただし、どのようなrを選んでもx人以下にすることが不可能であればNAと出力する。
入力例 1
-----
```
5 8
5
10
8
7
3
ADD 1
ADD 3
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
```
出力例 1
-----
```
NA
2
1
0
0
0
```
入力例 2
-----
```
5 28
5
10
8
7
3
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
ADD 1
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
REMOVE 1
ADD 3
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
ADD 1
CHECK 0
CHECK 1
CHECK 2
CHECK 3
CHECK 4
CHECK 5
```
出力例 2
-----
```
NA
NA
NA
NA
NA
0
NA
NA
NA
2
0
0
NA
5
3
1
0
0
NA
2
1
0
0
0
```
| #include<cstdio>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
using namespace std;
#define INF ( 1 << 30 )
typedef multiset<int,int>::iterator itr;
int main()
{
int N, Q;
int stmp[1000000], comp[1000000], a;
char buff[1024];
scanf( "%d %d", &N, &Q);
for(int i = 0 ; i < N ; i++ ){
scanf( "%d", &stmp[i]);
comp[i] = stmp[i];
}
sort( comp, comp + N);
multiset< int > sym;
while(Q--){
scanf("%s %d", buff, &a);
if(*buff == 'A'){ //ADD
sym.insert(stmp[a - 1]);
} else if(*buff == 'R'){ //REMOVE
try{
sym.erase( sym.lower_bound(stmp[a - 1]));
}catch( ... ){}
} else { //CHECK
int left = 0, right = INF;
while(left != right){
int center = ( left + right ) / 2;
int pre = 0, BAN = 0;
for(itr it = sym.begin() ; it != sym.end() ; it++ ){
int p = distance( comp,lower_bound( comp, comp + N, *it - center));
BAN += max( p - pre, 0);
pre = distance( comp, upper_bound( comp, comp + N, *it));
}
BAN += max( N - pre, 0);
if(BAN <= a) right = center;
else left = center + 1;
}
if( left != INF) printf("%d\n", left);
else puts("NA");
}
}
return false;
} | #include<bits/stdc++.h>
using namespace std;
int N, Q;
vector< int > values, s;
vector< int > reader;
bool calc(int value, int a){ //reader[i]以下reader[i]-value以上
int pre = 0, ng = 0;
for(int i = 0; i < reader.size(); i++){
int pos = lower_bound( values.begin(), values.end(), reader[i] - value) - values.begin(); //reader[i]-value以上
ng += max( 0, pos - pre);
pre = upper_bound( values.begin(), values.end(), reader[i]) - values.begin(); //reader[i]以下
}
ng += max< int >( 0, N - pre);
return (ng <= a);
}
int main(){
scanf("%d %d", &N, &Q);
values.resize(N), s.resize(N);
for(int i = 0; i < N; i++){
scanf("%d", &s[i]);
values[i] = s[i];
}
sort(values.begin(), values.end());
while(Q--){
char query[100];
int a;
scanf("%s %d", query, &a);
if(strcmp(query,"ADD") == 0){
a--;
reader.push_back(s[a]);
sort( reader.begin(), reader.end());
} else if(strcmp(query,"REMOVE") == 0){
a--;
reader.erase(lower_bound( reader.begin(), reader.end(), s[a]));
} else {
int row = 0, high = 1000000001;
while(high != row){
int mid = (row + high) >> 1;
if(calc(mid, a)) high = mid;
else row = mid + 1;
}
if(row == 1000000001) puts("NA");
else printf("%d\n", row);
}
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
親方の給料計算
-------
ワシはパイプつなぎ組合の親方じゃ。職人を工事現場に派遣し、現場でパイプをつながせておる。去年は工事が増えて大儲けするかと思ったのじゃが、ちょっと給料の出し方がまずくてのぅ。ウチとしては大赤字になってしまったのじゃよ…。そこで、今年は職人たちへの給料の出し方を工夫したいのじゃ。
職人たちの給料は、工事の種類とこなした回数で決めておる。つまり、
職人の給料 ＝ 種類 1 の単価 × 種類 1 をこなした回数
+ 種類 2 の単価 × 種類 2 をこなした回数
....
+ 種類 M の単価 × 種類 M をこなした回数
となるのじゃ。これを計算するために、ウチでは、どの職人がどの種類の工事を何回こなしたかを次のような表に記録しておる。
例えば、上の表では、職人１が工事２を２回、工事４を１回こなしたことを示しておる。
職人たちがこなした仕事の回数はもう変えられんが、やつらは工事の単価を知らんので、単価をいろいろと変えながら皆の不満が出ぬよう給料を調整しようと思うておる。じゃが、ワシがこしらえたプログラムが今もって動かなくてのぅ。ちょっとみてくれんかね。
```
//省略
int i, j;
for ( i = 0; i < N; i++ ){
c[i] = 0;
for ( j = 0; j < M; j++ ){
c[i] = c[i] + a[i][j]*b[j];
}
}
//省略
```
N は職人の数で M は工事の種類の数じゃ。変数 a[i][j] に職人iが工事 j をこなした回数を、b[j] に工事 j の単価をいれて、c[i] に職人 i の給料を格納しておる。合っているはずなのに、うんともすんとも言わん！そろそろ今年の給料を職人たちに払わないとまずいのじゃが・・・・・なんとかならんかのぅ。
それでは、職人のこなした仕事の回数と各工事の単価の情報が与えられたとき、各職人の給料を計算するプログラムを作成してください。
入力
--
入力は1つのデータセットからなる。入力データは以下の形式で与えられる。
```
N M
s1 t1 e1
s2 t2 e2
:
0 0 0
L
b11 b12 ... b1M
b21 b22 ... b2M
:
bL1 bL2 ... bLM
```
* 1行目は職人の数 N(1 ≤ N ≤ 10000)と工事の種類の数 M(1 ≤ M ≤ 10000)。
* 続いて、工事の記録として、職人の番号 si (1 ≤ si ≤ N) と工事の種類の番号 ti(1 ≤ ti ≤ M)、および職人 si が工事 ti をこなした回数 ei (1 ≤ ei ≤ 50000) からなる行が１行以上与えられる。工事の記録はゼロ３つの行で終わる。ただし、ei の合計は 1 以上 50000 以下である。また、工事の記録には、どの職人と工事の種類の組も２度以上現れない。工事をこなした回数が 0 である職人と工事の種類の組は与えられない。
* 続く 1 行は給料の算出を行う回数 L (1 ≤ L ≤ 100) 。
* 続く L 行は、i 回目の給料の算出に必要な、工事 j の単価 bij (0 ≤ bij ≤ 10000) の並び。
出力
--
以下の形式で、i 回目の給料の算出によって得られた職人 j の給料 cij を順番に出力する。各給料の間は空白１つで区切る。
```
c11 c12 ... c1N
c21 c22 ... c2N
:
cL1 cL2 ... cLN
```
入出力例
----
入力例
---
```
4 6
1 2 1
2 3 2
2 4 3
3 1 5
4 2 4
4 3 2
4 6 10
0 0 0
3
1 3 2 4 0 10
6 5 4 3 2 1
5 1 1 5 5 1
```
出力例
---
```
3 16 5 116
5 17 30 38
1 17 25 16
```
| #include <iostream>
using namespace std;
int N, M, L, R, s[50003], t[50003], e[50003], c[10003]; long long d[10003];
int main() {
cin >> N >> M;
while(true) {
cin >> s[R] >> t[R] >> e[R]; s[R]--, t[R]--;
if (!e[R]) break; R++;
}
cin >> L;
for (int i = 0; i < L; i++) {
for (int j = 0; j < M; j++) cin >> c[j];
for (int j = 0; j < N; j++) d[j] = 0;
for (int j = 0; j < R; j++) d[s[j]] += c[t[j]] * e[j];
for (int j = 0; j < N; j++) cout << (j ? " " : "") << d[j];
cout << endl;
}
} | #include <stdio.h>
int N, M, L, R, s[50003], t[50003], e[50003], c[10003]; long long d[10003];
int main() {
scanf("%d%d", &N, &M);
while(true) {
scanf("%d%d%d", s + R, t + R, e + R); s[R]--, t[R]--;
if (!e[R]) break; R++;
}
scanf("%d", &L);
for (int i = 0; i < L; i++) {
for (int j = 0; j < M; j++) scanf("%d", &c[j]);
for (int j = 0; j < N; j++) d[j] = 0;
for (int j = 0; j < R; j++) d[s[j]] += c[t[j]] * e[j];
for (int j = 0; j < N; j++) printf(j ? " %d" : "%d", d[j]);
printf("\n");
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
塵劫記
===
大きな数を表そうとすると、文字数も多くなるし、位取りがわからなくなってしまうので、なかなか面倒です。大きな数をわかりやすく表すために、人々は数の単位を使ってきました。江戸時代に書かれた「塵劫記」という本の中では、数の単位が次のように書かれています。
たとえば、２の１００乗のようなとても大きな数は、１２６穣７６５０(じょ)６００２垓２８２２京９４０１兆４９６７億３２０万５３７６と表せます。それでは、正の整数 m と n が与えられたとき、m の n 乗を塵劫記の単位を使って上のように表すプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ２つの行で示される。各データセットは以下の形式で与えられる。
```
m n
```
m (2 ≤ m ≤ 20) が基数、n (1 ≤ n < 240) が指数を表す。ただし、mnは 1072 未満である。
データセットの数は 100 を超えない。
出力
--
データセットごとに、mn を塵劫記の単位で表した文字列を1行に出力する。ただし、各単位は以下の表記で出力する。
mnを表す文字列は、1 から 9999 までの数と上の表に現れる単位を表す文字列からなる。文字列には、余分な 0 や単位を含めない。
入出力例
----
入力例
---
```
2 10
5 20
10 8
20 17
0 0
```
出力例
---
```
1024
95Cho3674Oku3164Man625
1Oku
131Gai720Kei
```
| #include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstdlib>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
string sum(string a, string b) {
if (a.size() > b.size()) swap(a, b);
int c = 0;
string res = "";
REP(i, a.size()) {
int x = a[a.size() - 1 - i] - '0' + b[b.size() - 1 - i] - '0' + c;
res.push_back(x % 10 + '0');
c = x / 10;
}
FOR(i, a.size(), b.size()) {
int x = b[b.size() - 1 - i] - '0' + c;
res.push_back(x % 10 + '0');
c = x / 10;
}
if (c > 0) res.push_back(c + '0');
reverse(res.begin(), res.end());
return res;
}
string kake(string a, string b) {
if (a == "0" || b == "0") return "0";
string res = "";
if (a.size() > b.size()) swap(a, b);
string s = "0";
REP(i, b.size()) {
REP(j, a.size()) {
int tmp = (a[a.size() - j - 1] - '0') * (b[b.size() - i - 1] - '0');
if (tmp > 0) {
stringstream ss;
ss << tmp;
REP(k, j) ss << "0";
s = sum(s, ss.str());
}
}
res.push_back(s[s.size() - 1]);
s.erase(s.end() - 1);
if (s.empty()) s = "0";
}
while (s != "0") {
res.push_back(s[s.size() - 1]);
s.erase(s.end() - 1);
if (s.empty()) s = "0";
}
reverse(res.begin(), res.end());
return res;
}
string pow(string x, int n) {
if (n == 0) return "1";
string res = pow(kake(x, x), n / 2);
if (n & 1) res = kake(res, x);
return res;
}
string jin[19] = {
"", "Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts"
};
int main() {
string m;
int n;
while (cin >> m >> n, m != "0" || n) {
string num = pow(m, n);
int pos = (num.size() - 1) / 4 ;
cout << num.substr(0, (num.size() - 1) % 4 + 1) << jin[pos];
while (--pos >= 0) {
string out = num.substr((num.size() - 1) % 4 + 1 + ((num.size() - 1) / 4 - pos - 1) * 4, 4);
if (atoi(out.c_str()) > 0) cout << atoi(out.c_str()) << jin[pos];
}
puts("");
}
} | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstdlib>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
string sum(string a, string b) {
if (a.size() > b.size()) swap(a, b);
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
string res = "";
int c = 0;
REP(i, a.size()) {
c += a[i] - '0' + b[i] - '0';
res.push_back(c % 10 + '0');
c /= 10;
}
FOR(i, a.size(), b.size()) {
c += b[i] - '0';
res.push_back(c % 10 + '0');
c /= 10;
}
if (c > 0) res.push_back(c + '0');
reverse(res.begin(), res.end());
return res;
}
string kake(string a, string b) {
if (a == "0" || b == "0") return "0";
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
string res = "0";
REP(i, a.size()) {
string plus = "";
int c = 0;
REP(j, b.size()) {
c += (a[i] - '0') * (b[j] - '0');
plus.push_back(c % 10 + '0');
c /= 10;
}
if (c > 0) plus.push_back(c % 10 + '0');
reverse(plus.begin(), plus.end());
REP(j, i) plus.push_back('0');
res = sum(res, plus);
}
return res;
}
string pow(string x, int n) {
if (n == 0) return "1";
string res = pow(kake(x, x), n / 2);
if (n & 1) res = kake(res, x);
return res;
}
string jin[19] = {
"", "Man","Oku","Cho","Kei","Gai","Jo","Jou","Ko","Kan","Sei","Sai","Gok","Ggs","Asg","Nyt","Fks","Mts"
};
int main() {
string m;
int n;
while (cin >> m >> n, m != "0" || n) {
string num = pow(m, n);
int pos = (num.size() - 1) / 4 ;
cout << num.substr(0, (num.size() - 1) % 4 + 1) << jin[pos];
while (--pos >= 0) {
string out = num.substr((num.size() - 1) % 4 + 1 + ((num.size() - 1) / 4 - pos - 1) * 4, 4);
if (atoi(out.c_str()) > 0) cout << atoi(out.c_str()) << jin[pos];
}
puts("");
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
巨樹の刻み手
======
あなたは N 種類の道具を使って、目の前の巨樹を切り倒そうとしています。はじめは、樹の耐久力は D、あなたの経験値は 0 ですが、道具 i で１回樹を叩くと樹の耐久力は ai 減り、あなたは ei の経験値を得ます。ただし、道具 i を使うためには、あなたは ri 以上の経験値を持っていなければなりません。樹の耐久力が 0 以下になると樹は倒れます。
樹の耐久力と道具についての情報が与えられたとき、樹を切り倒すには最低何回樹を叩かなければいけないかを求めるプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ２つの行で示される。各データセットは以下の形式で与えられる。
```
D N
a1 e1 r1
a2 e2 r2
:
aN eN rN
```
1 行目に樹の耐久力を表す整数 D (1 ≤ D ≤ 100) と道具の種類の数 N(1 ≤ N ≤ 100) が与えられる。続く N 行に道具 1 から N までの情報が与えられる。ai (0 ≤ ai ≤ 100) と ei (0 ≤ ei ≤ 100) は、道具iを１回使うことで減る樹の耐久力とあなたが得ることのできる経験値をそれぞれ表す。ri (0 ≤ ri ≤ 100) は道具を使うために必要な経験値を表す。ai, ei, ri はすべて整数である。
データセットの数は 50 を超えない。
出力
--
樹を切り倒すのに必要な、樹を叩く最小の回数を１行に出力する。ただし、樹を切り倒すことが不可能な場合は NA と出力する。
入出力例
----
入力例
---
```
15 4
1 1 0
1 2 2
5 10 5
8 1 15
60 4
5 2 0
8 8 2
3 5 0
49 0 18
100 1
1 1 1
0 0
```
出力例
---
```
6
4
NA
```
| #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define REPR(i,n) for (int i=(int)(n)-1;i>=0;--i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
const int dy[] = {-1,0,1,0};
const int dx[] = {0,1,0,-1};
typedef long long ll;
typedef pair<int,int> pii;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>&os,
const C& c){os<<'[';for(auto i=begin(c);i!=end(c);++i)os<<(i==begin(c)?"":" ")<<*i;return os<<']';}
template<class S,class T>ostream&operator<<(ostream &o,const pair<S,T>&t){return o<<'('<<t.first<<','<<t.second<<')';}
template<int N,class Tp>void output(ostream&,const Tp&){}
template<int N,class Tp,class,class ...Ts>void output(ostream &o,const Tp&t){if(N)o<<',';o<<get<N>(t);output<N+1,Tp,Ts...>(o,t);}
template<class ...Ts>ostream&operator<<(ostream&o,const tuple<Ts...>&t){o<<'(';output<0,tuple<Ts...>,Ts...>(o,t);return o<<')';}
template<class T>void output(T t,char z=10){if(t<0)t=-t,putchar(45);int c[20];
int k=0;while(t)c[k++]=t%10,t/=10;for(k||(c[k++]=0);k;)putchar(c[--k]^48);putchar(z);}
template<class T>void outputs(T t){output(t);}
template<class S,class ...T>void outputs(S a,T...t){output(a,32);outputs(t...);}
template<class T>void output(T *a,int n){REP(i,n)cout<<a[i]<<(i!=n-1?',':'\n');}
template<class T>void output(T *a,int n,int m){REP(i,n)output(a[i],m);}
template<class T>bool input(T &t){int n=1,c;for(t=0;!isdigit(c=getchar())&&~c&&c-45;);
if(!~c)return 0;for(c-45&&(n=0,t=c^48);isdigit(c=getchar());)t=10*t+c-48;t=n?-t:t;return 1;}
template<class S,class ...T>bool input(S&a,T&...t){input(a);return input(t...);}
template<class T>bool inputs(T *a, int n) { REP(i,n) if(!input(a[i])) return 0; return 1;}
int dp[101][101][101];
struct P {
int a,e,r;
void in() {
cin >> a >> e >> r;
}
bool operator<(const P &rhs) const {
return r < rhs.r;
}
} p[100];
int main() {
int d,n;
while(cin>>d>>n,d||n) {
REP(i,n) {
p[i].in();
}
sort(p,p+n);
memset(dp,0x3f,sizeof(dp));
dp[0][0][0] = 0;
REP(i,n) {
for (int j=0; j <= 100; ++j) {
REP(k,d+1) {
chmin(dp[i+1][j][k], dp[i][j][k]);
if (j>=p[i].r) {
chmin(dp[i+1][min(100,j+p[i].e)][min(d,k+p[i].a)], dp[i+1][j][k] + 1);
// REP(l,100) {
// chmin(dp[i+1][min(100,j+p[i].e*l)][min(d,k+p[i].a*l)], dp[i][j][k] + l);
// }
}
}
}
}
int ans = INF;
REP(i,101) chmin(ans, dp[n][i][d]);
if (ans == INF) puts("NA");
else cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 0x3f3f3f3f;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename Ch,typename Tr,typename C,typename=decltype(begin(C()))>basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>&os,
const C& c){os<<'[';for(auto i=begin(c);i!=end(c);++i)os<<(i==begin(c)?"":" ")<<*i;return os<<']';}
int a[100];
int e[100];
int r[100];
int dp[101][101];
int main() {
int d,n;
while (cin>>d>>n, d||n) {
REP(i,n) {
cin >> a[i] >> e[i] >> r[i];
}
memset(dp,0x3f,sizeof(dp));
dp[0][0] = 0;
REP(i,d) {
REP(j,101) {
REP(k,n) {
if (j >= r[k]) {
chmin(dp[min(d,i+a[k])][min(100,j+e[k])], dp[i][j] + 1);
}
}
}
}
int ans = INF;
REP(j,101)
chmin(ans, dp[d][j]);
if (ans == INF) puts("NA");
else cout << ans << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
巨樹の刻み手
======
あなたは N 種類の道具を使って、目の前の巨樹を切り倒そうとしています。はじめは、樹の耐久力は D、あなたの経験値は 0 ですが、道具 i で１回樹を叩くと樹の耐久力は ai 減り、あなたは ei の経験値を得ます。ただし、道具 i を使うためには、あなたは ri 以上の経験値を持っていなければなりません。樹の耐久力が 0 以下になると樹は倒れます。
樹の耐久力と道具についての情報が与えられたとき、樹を切り倒すには最低何回樹を叩かなければいけないかを求めるプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ２つの行で示される。各データセットは以下の形式で与えられる。
```
D N
a1 e1 r1
a2 e2 r2
:
aN eN rN
```
1 行目に樹の耐久力を表す整数 D (1 ≤ D ≤ 100) と道具の種類の数 N(1 ≤ N ≤ 100) が与えられる。続く N 行に道具 1 から N までの情報が与えられる。ai (0 ≤ ai ≤ 100) と ei (0 ≤ ei ≤ 100) は、道具iを１回使うことで減る樹の耐久力とあなたが得ることのできる経験値をそれぞれ表す。ri (0 ≤ ri ≤ 100) は道具を使うために必要な経験値を表す。ai, ei, ri はすべて整数である。
データセットの数は 50 を超えない。
出力
--
樹を切り倒すのに必要な、樹を叩く最小の回数を１行に出力する。ただし、樹を切り倒すことが不可能な場合は NA と出力する。
入出力例
----
入力例
---
```
15 4
1 1 0
1 2 2
5 10 5
8 1 15
60 4
5 2 0
8 8 2
3 5 0
49 0 18
100 1
1 1 1
0 0
```
出力例
---
```
6
4
NA
```
| #include <iostream>
#include <algorithm>
using namespace std;
int D, N, a[111], e[111], r[111], dp[111][111];
int main() {
while (cin >> D >> N, D | N) {
for (int i = 0; i < N; i++) cin >> a[i] >> e[i] >> r[i];
int maxr = *max_element(r, r + N);
for (int i = 0; i <= D; i++) fill(dp[i], dp[i] + maxr + 1, 999999999);
dp[0][0] = 0;
for (int i = 0; i < D; i++) {
for (int j = 0; j <= maxr; j++) {
for (int k = 0; k < N; k++) {
if (j < r[k]) continue;
int p = min(j + e[k], maxr), q = min(i + a[k], D);
dp[q][p] = min(dp[q][p], dp[i][j] + 1);
}
}
}
int ret = *min_element(dp[D], dp[D] + maxr + 1);
if (ret == 999999999) cout << "NA" << endl;
else cout << ret << endl;
}
} | #include <cstdio>
#include <algorithm>
#pragma warning(disable : 4996)
using namespace std;
int D, N, a[111], e[111], r[111], dp[111][111];
int main() {
while (scanf("%d%d", &D, &N), D | N) {
for (int i = 0; i < N; i++) scanf("%d%d%d", a + i, e + i, r + i);
int maxr = *max_element(r, r + N);
for (int i = 0; i <= D; i++) fill(dp[i], dp[i] + maxr + 1, 999999999);
dp[0][0] = 0;
for (int i = 0; i < D; i++) {
for (int j = 0; j <= maxr; j++) {
for (int k = 0; k < N; k++) {
if (j < r[k]) continue;
int p = min(j + e[k], maxr), q = min(i + a[k], D);
dp[q][p] = min(dp[q][p], dp[i][j] + 1);
}
}
}
int ret = *min_element(dp[D], dp[D] + maxr + 1);
if (ret == 999999999) puts("NA");
else printf("%d\n", ret);
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
巨樹の刻み手
======
あなたは N 種類の道具を使って、目の前の巨樹を切り倒そうとしています。はじめは、樹の耐久力は D、あなたの経験値は 0 ですが、道具 i で１回樹を叩くと樹の耐久力は ai 減り、あなたは ei の経験値を得ます。ただし、道具 i を使うためには、あなたは ri 以上の経験値を持っていなければなりません。樹の耐久力が 0 以下になると樹は倒れます。
樹の耐久力と道具についての情報が与えられたとき、樹を切り倒すには最低何回樹を叩かなければいけないかを求めるプログラムを作成してください。
入力
--
入力は複数のデータセットからなる。入力の終わりはゼロ２つの行で示される。各データセットは以下の形式で与えられる。
```
D N
a1 e1 r1
a2 e2 r2
:
aN eN rN
```
1 行目に樹の耐久力を表す整数 D (1 ≤ D ≤ 100) と道具の種類の数 N(1 ≤ N ≤ 100) が与えられる。続く N 行に道具 1 から N までの情報が与えられる。ai (0 ≤ ai ≤ 100) と ei (0 ≤ ei ≤ 100) は、道具iを１回使うことで減る樹の耐久力とあなたが得ることのできる経験値をそれぞれ表す。ri (0 ≤ ri ≤ 100) は道具を使うために必要な経験値を表す。ai, ei, ri はすべて整数である。
データセットの数は 50 を超えない。
出力
--
樹を切り倒すのに必要な、樹を叩く最小の回数を１行に出力する。ただし、樹を切り倒すことが不可能な場合は NA と出力する。
入出力例
----
入力例
---
```
15 4
1 1 0
1 2 2
5 10 5
8 1 15
60 4
5 2 0
8 8 2
3 5 0
49 0 18
100 1
1 1 1
0 0
```
出力例
---
```
6
4
NA
```
| #include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
int d, n;
vector <int> a, e, r;
vector <vector <int>> memo;
const int INF = 1000000000;
void rec(int c = 0, int exp = 0, int end = d) {
if (memo[exp][end] <= c) return;
memo[exp][end] = c;
rep (i, n) {
if (exp < r[i]) continue;
rec(c + 1, min(exp + e[i], 100), max(end - a[i], 0));
}
}
int main() {
while (cin >> d >> n, d) {
a = e = r = vector <int> (n);
rep (i, n) cin >> a[i] >> e[i] >> r[i];
memo = vector <vector <int>> (105, vector <int> (105, INF));
rec();
int ans = INF;
rep (i, 101) ans = min(ans, memo[i][0]);
cout << (ans == INF ? "NA" : to_string(ans)) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
const int INF = 1000000000;
int main() {
int d, n;
while (cin >> d >> n, d) {
int a[n], e[n], r[n];
rep (i, n) cin >> a[i] >> e[i] >> r[i];
//耐久値、経験値
int dp[d + 1][101];
rep (i, d + 1) rep (j, 101) dp[i][j] = INF;
dp[d][0] = 0;
for (int i = d; i >= 0; i--) rep (j, 101) {
if (dp[i][j] == INF) continue;
rep (k, n) {
if (r[k] > j) continue;
//a[i] -> 減る耐久値, e[i] -> 得る経験値
dp[max(0, i - a[k])][min(100, j + e[k])] = min(dp[max(0, i - a[k])][min(100, j + e[k])],
dp[i][j] + 1);
}
}
int ans = INF;
rep (i, 101) ans = min(ans, dp[0][i]);
cout << (ans == INF ? "NA" : to_string(ans)) << endl;
}
return 0;
}
| C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
無限急行
====
ムゲン鉄道のムゲン線には無限個の駅があります。駅には …, -3, -2, -1, 0, 1, 2, 3, … と番号が振られていて、各駅は数直線上の整数と同じ順番で隣り合っています。あなたはいま、ある番号の駅から電車に乗り、それより大きな番号の駅に向かおうとしています。
ムゲン線には無限種類の快速電車が走っています。それらは 0 級快速、1 級快速、2 級快速、3 級快速、… のように番号で呼ばれています。n 級快速の電車は、2n の倍数の番号の駅に停車します。たとえば、1級快速は駅 …, -4, -2, 0, 2, 4, … に、3 級快速は駅 …, -24, -16, -8, 0, 8, 16, 24, … に停車するといった具合です。0 級快速はすべての駅に停車するので、本当は各駅停車ですがムゲン鉄道は「快速」と呼んでいます。
どの級の快速電車も、ある停車駅から次の停車駅まで移動するのに1単位時間かかります。また、快速電車間の乗り換えにかかる時間は無視できるものとします。乗車駅 s と降車駅 d が与えられたとき、s から d へ移動するのに必要な最小の時間を求めるプログラムを作成してください。ただし、s から d へ移動する間に、大きな番号から小さな番号の駅に向かっての移動は認められないものとします。
入力
--
入力は1つのデータセットからなる。入力データは以下の形式で与えられる。
```
N
s1 d1
s2 d2
:
sN dN
```
１行目に移動の回数を表す N (1 ≤ N ≤ 100) が与えられる。続く N 行に、乗車駅の番号 si と降車駅の番号 di (-1,000,000,000 ≤ si < di ≤ 1,000,000,000) が与えられる。
出力
--
与えられた乗車駅と降車駅ごとに、移動に必要な最小の時間を１行に出力する。
入出力例
----
入力例
---
```
3
0 7
-1048576 0
-3 5
```
出力例
---
```
3
1
4
```
| #define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
#define all(c) begin(c), end(c)
#define loop(i,a,b) for(ll i=a; i<ll(b); i++)
#define rep(i,b) loop(i,0,b)
#define loopi(i,a,b) for(ll a=a;i<=ll(b);i++)
#define repi(i,b) loopi(i,1,b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
template<class T> ostream & operator << (ostream &os, vector<T> const &);
template<int n, class...T>
typename enable_if<(n>=sizeof...(T))>::type
_ot(ostream &, tuple<T...> const &){}
template<int n, class...T>
typename enable_if<(n< sizeof...(T))>::type
_ot(ostream &os, tuple<T...> const &t){
os << (n==0?"":" ") << get<n>(t); _ot<n+1>(os, t);
}
template<class...T>
ostream & operator << (ostream &os, tuple<T...> const &t){
_ot<0>(os, t); return os;
}
template<class T, class U>
ostream & operator<<(ostream &os, pair<T,U> const &p){
return os << "(" << p.first << ", " << p.second << ") ";
}
template<class T>
ostream & operator<<(ostream &os, vector<T> const &v){
rep(i,v.size()) os << v[i] << (i+1==(int)v.size()?"":" "); return os;
}
#ifdef DEBUG
#define dump(...) (cerr << #__VA_ARGS__ << " = " << mt(__VA_ARGS__) \
<< " [" << __LINE__ << "]" << endl)
#else
#define dump(...)
#endif
void fastios(){
ios_base::sync_with_stdio(0);
cin.tie(0);
// #define endl "\n"
}
template<class T>
size_t uniq(vector<T> &v){
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v.size();
}
template<class T>
size_t uniq(T *l, size_t n){
sort(l,l+n);
return unique(l,n) - l;
}
#define mems(arr,val) memset(arr,val,sizeof(arr));
int const mod = 1000000007;
int const inf = numeric_limits<int>::max()/10;
int popcount(unsigned long long x){
static int dp[66000];
if(dp[65536] != 16) for(int i = 0; i < 65536; i++) dp[i] = (i&1) + dp[i>>1];
int res = 0;
while(x) res += dp[x&65535], x >>= 16;
return res;
}
int solve(ll s, ll d){
//if(s <= 0 && d >= 0) return __builtin_popcount(-s) + __builtin_popcount(d);
if(s <= 0 && d >= 0) return popcount(-s) + popcount(d);
else if(s >= 0 && d >= 0){
int j = 0;
int ans = 0;
while(s < d){
if((s>>j&1) && (d>>j&1)){
s += 1LL<<j;
d -= 1LL<<j;
ans += 2;
} else if((s>>j&1) ^ (d>>j&1)){
s += 1LL<<j;
ans ++;
}
j++;
}
return ans;
} else return solve(-d,-s);
}
signed main(){
fastios();
int N;
cin >> N;
rep(i,N){
ll s,d;
cin >> s >> d;
cout << solve(s,d) << endl;
}
} | #define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
#define all(c) begin(c), end(c)
#define loop(i,a,b) for(ll i=a; i<ll(b); i++)
#define rep(i,b) loop(i,0,b)
#define loopi(i,a,b) for(ll a=a;i<=ll(b);i++)
#define repi(i,b) loopi(i,1,b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
template<class T> ostream & operator << (ostream &os, vector<T> const &);
template<int n, class...T>
typename enable_if<(n>=sizeof...(T))>::type
_ot(ostream &, tuple<T...> const &){}
template<int n, class...T>
typename enable_if<(n< sizeof...(T))>::type
_ot(ostream &os, tuple<T...> const &t){
os << (n==0?"":" ") << get<n>(t); _ot<n+1>(os, t);
}
template<class...T>
ostream & operator << (ostream &os, tuple<T...> const &t){
_ot<0>(os, t); return os;
}
template<class T, class U>
ostream & operator<<(ostream &os, pair<T,U> const &p){
return os << "(" << p.first << ", " << p.second << ") ";
}
template<class T>
ostream & operator<<(ostream &os, vector<T> const &v){
rep(i,v.size()) os << v[i] << (i+1==(int)v.size()?"":" "); return os;
}
#ifdef DEBUG
#define dump(...) (cerr << #__VA_ARGS__ << " = " << mt(__VA_ARGS__) \
<< " [" << __LINE__ << "]" << endl)
#else
#define dump(...)
#endif
void fastios(){
ios_base::sync_with_stdio(0);
cin.tie(0);
// #define endl "\n"
}
template<class T>
size_t uniq(vector<T> &v){
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v.size();
}
template<class T>
size_t uniq(T *l, size_t n){
sort(l,l+n);
return unique(l,n) - l;
}
#define mems(arr,val) memset(arr,val,sizeof(arr));
int const mod = 1000000007;
int const inf = numeric_limits<int>::max()/10;
int popcount(unsigned long long x){
static int dp[66000];
if(dp[65535] != 16) for(int i = 0; i < 65536; i++) dp[i] = (i&1) + dp[i>>1];
int res = 0;
while(x) res += dp[x&65535], x >>= 16;
return res;
}
int solve(ll s, ll d){
//if(s <= 0 && d >= 0) return __builtin_popcount(-s) + __builtin_popcount(d);
if(s <= 0 && d >= 0) return popcount(-s) + popcount(d);
else if(s >= 0 && d >= 0){
int j = 0;
int ans = 0;
while(s < d){
if((s>>j&1) && (d>>j&1)){
s += 1LL<<j;
d -= 1LL<<j;
ans += 2;
} else if((s>>j&1) ^ (d>>j&1)){
s += 1LL<<j;
ans ++;
}
j++;
}
return ans;
} else return solve(-d,-s);
}
signed main(){
fastios();
int N;
cin >> N;
rep(i,N){
ll s,d;
cin >> s >> d;
cout << solve(s,d) << endl;
}
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
フロッピーキューブ
=========
フロッピーキューブをプログラミングで解いてみましょう。フロッピーキューブは図のように表面に色のついた９個の立方体から構成されている立体パズルで、キューブの列を回転させることによって、６つの各面の色をそろえます。
フロッピーキューブに対しては下図のような４種類の操作を行うことができ、一回の操作で、端にある３つの隣接したキューブを１８０度回転することができます。わかりやすいように、図では、上面に＋(赤色)、下面に＊(緑色)、右前面に□(黄色)、左前面に●(青色)、右奥面に○(水色)、左奥面に■紫色) の記号が付いている状態を初期状態としています。
フロッピーキューブの初期状態が与えられるので、パズルを解くために必要な最小の操作回数を求めるプログラムを作成してください。
入力
--
入力は以下の形式で与えられる。
```
N
puzzle1
puzzle2
:
puzzleN
```
１行目のN (1 ≤ N ≤ 30) は操作回数を計算したいパズルの数である。続くN行に各フロッピーキューブの初期状態 puzzlei が与えられる。puzzlei は以下の形式で与えられる。
```
p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 p16 p17 p18 p19 p20 p21 p22 p23 p24 p25 p26 p27 p28 p29 p30
```
各フロッピーキューブの情報は 30 個の整数 pi (1 ≤ pi ≤ 6) からなる。pi は、下図のようにフロッピーキューブの各面に番号 i を振ったときの、そのキューブの面の色を表す。
パズルは、多くとも８回の操作で解くことができると仮定してよい。
出力
--
パズルごとに、最小の操作回数を１行に出力する。
入出力例
----
入力例
---
```
4
1 1 1 1 1 1 1 1 1 2 2 2 4 4 4 6 6 6 5 5 5 3 3 3 3 3 3 3 3 3
3 3 3 1 1 1 1 1 1 2 2 2 4 4 6 4 6 6 5 5 5 3 3 3 3 3 3 1 1 1
3 3 3 1 1 3 1 1 1 2 2 5 6 4 4 4 6 6 2 5 5 3 3 3 1 3 3 1 1 1
1 3 1 3 1 3 3 1 3 2 2 2 6 4 4 6 6 4 5 5 5 1 3 1 1 3 1 3 1 3
```
出力例
---
```
0
1
2
7
```
| #include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <climits>
#include <algorithm>
#include <map>
using namespace std;
int N, p[30], min_times;
map<int,int> rot[4] = {
{ {1, 28}, {2, 29}, {3, 30}, {15, 16}, {19, 21}, },
{ {3, 22}, {6, 25}, {9, 28}, {12, 19}, {13, 15} },
{ {7, 22}, {8, 23}, {9, 24}, {13, 18}, {10, 12} },
{ {1, 24}, {4, 27}, {7, 30}, {10, 21}, {16, 18} }
};
vector<int> group_id = {
0, 0, 0, 0, 0, 0, 0, 0, 0,
9, 9, 9,
12, 12, 12,
15, 15, 15,
18, 18, 18,
21, 21, 21, 21, 21, 21, 21, 21, 21
};
void rotate(int i) {
for (auto it=rot[i].begin(); it!=rot[i].end(); ++it) {
swap(p[it->first - 1], p[it->second - 1]);
}
}
bool isOK() {
for (int i=0; i<(int)group_id.size(); ++i) {
if (p[i] != p[group_id[i]]) return false;
}
return true;
}
int solve(int times, int &min_times) {
if (8 <= times || min_times <= times || isOK()) {
min_times = min(min_times, times);
return times;
}
int ret = INT_MAX;
for (int i=0; i<4; ++i) {
rotate(i);
ret = min(ret, solve(times + 1, min_times));
rotate(i);
}
return ret;
}
int main() {
cin >> N;
for (int i=0; i<N; ++i) {
for (int j=0; j<30; ++j) {
cin >> p[j];
}
min_times = INT_MAX;
cout << solve(0, min_times) << endl;
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
int N, p[30], min_times;
map<int,int> rot[4] = {
{ {1, 28}, {2, 29}, {3, 30}, {15, 16}, {19, 21}, },
{ {3, 22}, {6, 25}, {9, 28}, {12, 19}, {13, 15} },
{ {7, 22}, {8, 23}, {9, 24}, {13, 18}, {10, 12} },
{ {1, 24}, {4, 27}, {7, 30}, {10, 21}, {16, 18} }
};
vector<int> group_id = {
0, 0, 0, 0, 0, 0, 0, 0, 0,
9, 9, 9,
12, 12, 12,
15, 15, 15,
18, 18, 18,
21, 21, 21, 21, 21, 21, 21, 21, 21
};
void rotate(int i) {
for (auto it=rot[i].begin(); it!=rot[i].end(); ++it) {
swap(p[it->first - 1], p[it->second - 1]);
}
}
bool isOK() {
for (int i=0; i<(int)group_id.size(); ++i) {
if (p[i] != p[group_id[i]]) return false;
}
return true;
}
int solve(int times, int &min_times) {
if (min_times <= times || isOK()) {
min_times = min(min_times, times);
return times;
} else if (times == 7) {
return 8;
}
int ret = 8;
for (int i=0; i<4; ++i) {
rotate(i);
ret = min(ret, solve(times + 1, min_times));
rotate(i);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i=0; i<N; ++i) {
for (int j=0; j<30; ++j) {
cin >> p[j];
}
min_times = 8;
cout << solve(0, min_times) << endl;
}
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
バトンリレーゲーム
=========
アカベ高校では、毎年全校生徒が参加するゲームを行っています。まず、校庭に N 人の全校生徒が円形に並びます。図のように、各生徒は 0 から N-1 までの番号が書かれたゼッケンを付けています。
ゲームではバトンを１本使い、最初はゼッケン 0 番の生徒がバトンを持っています。そこから、以下の手順を M 回繰り返します。まず、現時点でバトンを持っている生徒が適当な正の整数 a を宣言します。a が偶数のときは時計回り、奇数のときは反時計回りに隣の生徒にバトンを渡していき、a 番目にバトンを受け取った生徒が脱落します。脱落した生徒は、時計回りで隣の生徒にバトンを渡し、円から抜けます。
ゲームが終わった後に円に残った生徒は、放課後の掃除が１年間免除されます。しかし、ここ数年は生徒数が増えたため、全校生徒を集めるのが難しくなってきています。そこで、競技プログラミング部のあなたは、シミュレーションで掃除が免除される生徒を求めるプログラムを作成するよう頼まれました。
指定した生徒が掃除を免除されているかどうかを質問したとき、それに答えるプログラムを作成してください。
入力
--
入力は以下の形式で与えられる。
```
N M Q
a1 a2 ... aM
q1 q2 ... qQ
```
入力は３行であり、１行目に生徒の人数 N (10 ≤ N ≤ 200000)、繰り返し回数 M (5 ≤ M < N)、生徒が掃除を免除されるかどうかを問い合わせる質問の個数 Q (1 ≤ Q ≤ 1000) が与えられる。続く１行に、i 回目の繰り返しで最初にバトンを持っている生徒が宣言する整数ai (1 ≤ ai ≤ 100) が与えられる。続く１行に、質問としてゼッケン番号 qi (0 ≤ q < N) が与えられる。
出力
--
質問ごとに、ゼッケン番号 qi の生徒が掃除を免除されるかどうかを i 行目に出力する。掃除が免除されるなら 1 を、されないなら 0 を出力する。
入出力例
----
入力例
---
```
10 5 3
2 6 5 18 3
3 0 5
```
出力例
---
```
1
0
1
```
| #include <iostream>
using namespace std;
int N, M, Q, p, r, a, prv[200007], nxt[200007];
int main() {
cin >> N >> M >> Q;
for (int i = 0; i < N; i++) prv[i] = (i + N - 1) % N, nxt[i] = (i + 1) % N;
for (int i = 0; i < M; i++) {
cin >> a;
for (int j = 0; j < a; j++) p = a % 2 ? prv[p] : nxt[p];
nxt[prv[p]] = nxt[p], prv[nxt[p]] = prv[p];
r = nxt[p], prv[p] = nxt[p] = -1, p = r;
}
for (int i = 0; i < Q; i++) cin >> a, cout << (prv[a] != -1 ? 1 : 0) << endl;
return 0;
} | #include <stdio.h>
int N, M, Q, p, r, a, prv[200007], nxt[200007];
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 0; i < N; i++) prv[i] = (i + N - 1) % N, nxt[i] = (i + 1) % N;
for (int i = 0; i < M; i++) {
scanf("%d", &a);
for (int j = 0; j < a; j++) p = a % 2 ? prv[p] : nxt[p];
nxt[prv[p]] = nxt[p], prv[nxt[p]] = prv[p];
r = nxt[p], prv[p] = nxt[p] = -1, p = r;
}
for (int i = 0; i < Q; i++) scanf("%d", &a), puts(prv[a] != -1 ? "1" : "0");
return 0;
} | C++ | Runtime Efficiency | PIE4PERF_HQTRAIN |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.