Datasets:
ONLYSLIME
/
AOJ-CodeRank-Benchmark

Dataset card Data Studio Files
xet
 Community
1
group_id
stringlengths
12
18
problem_description
stringlengths
85
3.02k
candidates
listlengths
3
20
aoj_2320_cpp
Problem A: Infnity Maze Dr. Fukuoka has placed a simple robot in a two-dimensional maze. It moves within the maze and never goes out of the maze as there is no exit. The maze is made up of H × W grid cells as depicted below. The upper side of the maze faces north. Consequently, the right, lower and left sides face east, south and west respectively. Each cell is either empty or wall and has the coordinates of ( i , j ) where the north-west corner has (1, 1). The row i goes up toward the south and the column j toward the east. The robot moves on empty cells and faces north, east, south or west. It goes forward when there is an empty cell in front, and rotates 90 degrees to the right when it comes in front of a wall cell or on the edge of the maze. It cannot enter the wall cells. It stops right after moving forward by L cells. Your mission is, given the initial position and direction of the robot and the number of steps, to write a program to calculate the final position and direction of the robot. Input The input is a sequence of datasets. Each dataset is formatted as follows. H W L c 1,1 c 1,2 ... c 1, W . . . c H ,1 c H ,2 ... c H , W The first line of a dataset contains three integers H , W and L (1 ≤ H , W ≤ 100, 1 ≤ L ≤ 10 18 ). Each of the following H lines contains exactly W characters. In the i -th line, the j -th character c i,j represents a cell at ( i , j ) of the maze. " . " denotes an empty cell. " # " denotes a wall cell. " N ", " E ", " S ", " W " denote a robot on an empty cell facing north, east, south and west respectively; it indicates the initial position and direction of the robot. You can assume that there is at least one empty cell adjacent to the initial position of the robot. The end of input is indicated by a line with three zeros. This line is not part of any dataset. Output For each dataset, output in a line the final row, column and direction of the robot, separated by a single space. The direction should be one of the following: " N " (north), " E " (east), " S " (south) and " W " (west). No extra spaces or characters are allowed. Sample Input 3 3 10 E.. .#. ... 5 5 19 ####. ..... .#S#. ...#. #.##. 5 5 6 #.#.. #.... ##.#. #..S. #.... 5 4 35 ..## .... .##. .#S. ...# 0 0 0 Output for the Sample Input 1 3 E 4 5 S 4 4 E 1 1 N
[ { "submission_id": "aoj_2320_10568641", "code_snippet": "// competitive-verifier: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/2320\n#include <algorithm>\n#include <cstdint>\n#include <iostream>\n#include <iterator>\n#include <numeric>\n#include <string>\n#include <vector>\n#include <cassert>\n#include...
aoj_2324_cpp
Problem E: Full Text Search Mr. Don is an administrator of a famous quiz website named QMACloneClone. The users there can submit their own questions to the system as well as search for question texts with arbitrary queries. This search system employs bi-gram search method. The bi-gram search method introduces two phases, namely preprocessing and search: Preprocessing Precompute the set of all the substrings of one or two characters long for each question text. Search Compute the set for the query string in the same way. Then nd the question texts whose precomputed sets completely contain the set constructed from the query. Everything looked fine for a while after the feature was released. However, one of the users found an issue: the search results occasionally contained questions that did not include the query string as-is. Those questions are not likely what the users want. So Mr. Don has started to dig into the issue and asked you for help. For each given search query, your task is to find the length of the shortest question text picked up by the bi-gram method but not containing the query text as its substring. Input The input consists of multiple datasets. A dataset is given as a search query on each line. The input ends with a line containing only a hash sign (" # "), which should not be processed. A search query consists of no more than 1,000 and non-empty lowercase and/or uppercase letters. The question texts and queries are case-sensitive. Output For each search query, print the minimum possible length of a question text causing the issue. If there is no such question text, print " No Results " in one line (quotes only to clarify). Sample Input a QMAClone acmicpc abcdefgha abcdefgdhbi abcbcd # Output for the Sample Input No Results 9 7 9 12 6 Note Let's consider the situation that one question text is "CloneQMAC". In this situation, the set computed in the preprocessing phase is {"C", "Cl", "l", "lo", "o", "on", "n", "ne", "e", "eQ", "Q", "QM", "M", "MA", "A", "AC"}. In the testcase 2, our input text (search query) is "QMAClone". Thus the set computed by the program in the search phase is {"Q", "QM", "M", "MA", "A", "AC", "C", "Cl", "l", "lo", "o", "on", "n", "ne", "e"}. Since the first set contains all the elements in the second set, the question text "CloneQMAC" is picked up by the program when the search query is "QMAClone" although the text "CloneQ-MAC" itself does not contain the question text "QMAClone". In addition, we can prove that there's no such text of the length less than 9, thus, the expected output for this search query is 9.
[ { "submission_id": "aoj_2324_3161155", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define int long long\n#define all(v) (v).begin(), (v).end()\n#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)\n#define reps(i, m, n) for(int i = (int)(m); i < (int)(n); i++)\n#define rep(i, ...
aoj_2321_cpp
Problem B: Butterfly Claire is a man-eater. She's a real man-eater. She's going around with dozens of guys. She's dating all the time. And one day she found some conflicts in her date schedule. D'oh! So she needs to pick some dates and give the others up. The dates are set by hours like 13:00 to 15:00. She may have more than one date with a guy. For example, she can have dates with Adam from 10:00 to 12:00 and from 14:00 to 16:00 and with Bob from 12:00 to 13:00 and from 18:00 to 20:00. She can have these dates as long as there is no overlap of time. Time of traveling, time of make-up, trouble from love triangles, and the likes are not of her concern. Thus she can keep all the dates with Adam and Bob in the previous example. All dates are set between 6:00 and 22:00 on the same day. She wants to get the maximum amount of satisfaction in total. Each guy gives her some satisfaction if he has all scheduled dates. Let's say, for example, Adam's satisfaction is 100 and Bob's satisfaction is 200. Then, since she can make it with both guys, she can get 300 in total. Your task is to write a program to satisfy her demand. Then she could spend a few hours with you... if you really want. Input The input consists of a sequence of datasets. Each dataset has the following format: N Guy 1 ... Guy N The first line of the input contains an integer N (1 ≤ N ≤ 100), the number of guys. Then there come the descriptions of guys. Each description is given in this format: M L S 1 E 1 ... S M E M The first line contains two integers M i (1 ≤ M i ≤ 16) and L i (1 ≤ L i ≤ 100,000,000), the number of dates set for the guy and the satisfaction she would get from him respectively. Then M lines follow. The i -th line contains two integers S i and E i (6 ≤ S i < E i ≤ 22), the starting and ending time of the i -th date. The end of input is indicated by N = 0. Output For each dataset, output in a line the maximum amount of satisfaction she can get. Sample Input 2 2 100 10 12 14 16 2 200 12 13 18 20 4 1 100 6 22 1 1000 6 22 1 10000 6 22 1 100000 6 22 16 1 100000000 6 7 1 100000000 7 8 1 100000000 8 9 1 100000000 9 10 1 100000000 10 11 1 100000000 11 12 1 100000000 12 13 1 100000000 13 14 1 100000000 14 15 1 100000000 15 16 1 100000000 16 17 1 100000000 17 18 1 100000000 18 19 1 100000000 19 20 1 100000000 20 21 1 100000000 21 22 0 Output for the Sample Input 300 100000 1600000000
[ { "submission_id": "aoj_2321_11059617", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\nusing a2 = array<ll, 2>;\nusing a3 = array<ll, 3>;\n\nbool chmin(auto& a, const auto& b) { return a > b ? a = b, 1 : 0; }\nbool chmax(auto& a, const auto& b) { return a < b ? a = b...
aoj_2312_cpp
問題文 世の中の少女たちはキュゥべえと契約し願いを叶えてもらい，それとひきかえに魔法少女となる．使う魔法の形・効果は願いに強く影響を受ける．魔法少女 さやか ちゃんは最近キュゥべえと契約した新米魔法少女である． さやか の願いは「事故のため指が動かなくなり，音楽を演奏するのを諦めていた男の子を助けること」であったので，作る魔方陣は音符が輪の上に並んだ形をしている． さやか は N 個の音符を持っており，それらを輪の上に並べることによって魔方陣を作る．音符をどのような順番で並べるかは彼女の自由である．魔方陣を作るために精神力が消費され，その量は音符の配置によって以下のように決まる． まず， M 個の正の整数からなる 音楽的美しさ S_1,\ ...,\ S_M が定められている， 各音符は音程を持っており，音程は 1 から M の整数 K_1,\ ...,\ K_N で表される． 音程が a,\ b\ (a≤b) であるような 2 つの音符の間の 反発力 とは， [(S_a\ +\ ...\ +\ S_b) / L] で定められる量である．ここで， L は入力で与えられる定数であり，実数 x に対して [x] は x を越えない最大の整数を表すものとする． さやか の消費する精神力は，各2つの隣り合う音符 ( N 組存在する) の間の反発力の合計値である． 例えば音楽的美しさがそれぞれ \{100,\ 200,\ 300,\ 400,\ 500\} で，音程が \{1,\ 3,\ 5,\ 4\} である音符をこの順番で並べて魔方陣を作った時，消費される精神力は 37\ (=[(100+200+300)/99]+[(300+400+500)/99]+[(500+400)/99]+[(400+300+200+100)/99]) となる． 使うべき音符の音程の組み合わせと各音程の音楽的美しさが与えられるので，消費される精神力の最小値を求めよ． 入力形式 入力は以下の形式で与えられる． N\ M\ L\\ K_1\ K_2\ …\ K_N\\ S_1\ S_2\ …\ S_M N は さやか の持っている音符の数， M は音楽的美しさの値の個数， L は反発力を定めるのに使われる定数である． K_i は音符の音程を表し， S_j は音楽的美しさを表す． 出力形式 消費される精神力の最小値を 1 行に出力せよ． 制約 3 ≤ N ≤ 2,000 1 ≤ M ≤ 10 5 1 ≤ L ≤ 10 5 1 ≤ K_i ≤ M 1 ≤ S_j ≤ 10 5 入力値は全て整数である． 入出力例 入力例 1 4 5 99 1 4 5 3 100 200 300 400 500 出力例1 37 入力例 2 3 1 99 1 1 1 100 出力例 2 3 Problem Setter: Flat35
[ { "submission_id": "aoj_2312_10946081", "code_snippet": "#include \"bits/stdc++.h\"\n\nusing namespace std;\n#define FOR(i,s,t) for (int i = s; i < t; i++)\n#define SZ(x) (int)x.size()\nusing LL = long long; using ll = LL;\nusing VI = vector<int>; using VL = vector<LL>;\nconst LL INF = 1e9; const LL LINF = ...
aoj_2322_cpp
Problem C: Chinese Classics Taro, a junior high school student, is working on his homework. Today's homework is to read Chinese classic texts. As you know, Japanese language shares the (mostly) same Chinese characters but the order of words is a bit different. Therefore the notation called "returning marks" was invented in order to read Chinese classic texts in the order similar to Japanese language. There are two major types of returning marks: 'Re' mark and jump marks. Also there are a couple of jump marks such as one-two-three marks, top-middle-bottom marks. The marks are attached to letters to describe the reading order of each letter in the Chinese classic text. Figure 1 is an example of a Chinese classic text annotated with returning marks, which are the small letters at the bottom-left of the big Chinese letters. Figure 1: a Chinese classic text Taro generalized the concept of jump marks, and summarized the rules to read Chinese classic texts with returning marks as below. Your task is to help Taro by writing a program that interprets Chinese classic texts with returning marks following his rules, and outputs the order of reading of each letter. When two (or more) rules are applicable in each step, the latter in the list below is applied first, then the former. Basically letters are read downwards from top to bottom, i.e. the first letter should be read (or skipped) first, and after the i -th letter is read or skipped, ( i + 1)-th letter is read next. Each jump mark has a type (represented with a string consisting of lower-case letters) and a number (represented with a positive integer). A letter with a jump mark whose number is 2 or larger must be skipped. When the i -th letter with a jump mark of type t , number n is read, and when there exists an unread letter L at position less than i that has a jump mark of type t , number n + 1, then L must be read next. If there is no such letter L , the ( k + 1)-th letter is read, where k is the index of the most recently read letter with a jump mark of type t , number 1. A letter with a 'Re' mark must be skipped. When the i -th letter is read and ( i - 1)-th letter has a 'Re' mark, then ( i - 1)-th letter must be read next. No letter may be read twice or more. Once a letter is read, the letter must be skipped in the subsequent steps. If no letter can be read next, finish reading. Let's see the first case of the sample input. We begin reading with the first letter because of the rule 1. However, since the first letter has a jump mark ' onetwo2 ', we must follow the rule 2 and skip the letter. Therefore the second letter, which has no returning mark, will be read first. Then the third letter will be read. The third letter has a jump mark ' onetwo1 ', so we must follow rule 3 and read a letter with a jump mark `onetwo2' next, if exists. The first letter has the exact jump mark, so it will be read third. Similarly, the fifth letter is read fourth, and then the sixth letter is read. Although we have tw ...(truncated)
[ { "submission_id": "aoj_2322_10257213", "code_snippet": "// AOJ #2322 Chinese Classics\n// 2025.3.1\n\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define gc() getchar_unlocked()\n#define pc(c) putchar_unlocked(c)\n\nint Cin() { // 整数の入力\n\tint n = 0, c = gc();\n\tdo n = 10*n + (c & 0xf), c = gc(); w...
aoj_2325_cpp
Problem F: Mysterious Maze A robot in a two-dimensional maze again. The maze has an entrance and an exit this time, though. Just as in the previous problem, the maze is made up of H × W grid cells, its upper side faces north, and each cell is either empty or wall. Unlike the previous, on the other hand, one of the empty cells is connected to the entrance and another to the exit. The robot is rather complex - there is some control, but not full. It is associated with a controller that has two buttons, namely forward and turn . The forward button moves the robot forward to the next cell, if possible. The robot can not move into a wall nor outside the maze. The turn button turns the robot as programmed . Here the program is a finite sequence of N commands, each of which is either 'L' (indicating a left turn) or 'R' (a right turn). The first turn follows the first command; the second turn follows the second command; similar for the following turns. The turn button stops working once the commands are exhausted; the forward button still works in such a case though. The robot always turns by 90 degrees at once. The robot is initially put on the entrance cell, directed to the north. Your mission is to determine whether it can reach the exit cell if controlled properly. Input The input is a sequence of datasets. Each dataset is formatted as follows. H W N s 1 ... s N c 1,1 c 1,2 ... c 1, W ... c H ,1 c H ,2 ... c H , W The first line of a dataset contains three integers H , W and N (1 ≤ H , W ≤ 1,000, 1 ≤ N ≤ 1,000,000). The second line contains a program of N commands. Each of the following H lines contains exactly W characters. Each of these characters represents a cell of the maze. " . " indicates empty, " # " indicates a wall, " S " indicates an entrance, and " G " indicates an exit. There is exactly one entrance cell and one exit cell. The end of input is indicated by a line with three zeros. Output For each dataset, output whether the robot can reach the exit in a line: " Yes " if it can or " No " otherwise (without quotes). Sample Input 2 2 1 L G. #S 2 2 2 RR G. .S 3 3 6 LLLLLL G#. ... .#S 0 0 0 Output for the Sample Input Yes No Yes
[ { "submission_id": "aoj_2325_10858305", "code_snippet": "#include<stdio.h>\n#include<string.h>\n#include<math.h>\n#include<algorithm>\n#include <queue>\n//#define debug 1\nusing namespace std;\n\nconst int maxn = 1010;\nconst int inf = (1<<30);\n\nint dx[4] = {-1,0,1,0};\nint dy[4] = {0,1,0,-1};\n\nstruct n...
aoj_2326_cpp
Problem G: Number Sorting Consider sets of natural numbers. Some sets can be sorted in the same order numerically and lexicographically. {2, 27, 3125, 9000} is one example of such sets; {2, 27, 243} is not since lexicographic sorting would yield {2, 243, 27}. Your task is to write a program that, for the set of integers in a given range [ A , B ] (i.e. between A and B inclusive), counts the number of non-empty subsets satisfying the above property. Since the resulting number is expected to be very huge, your program should output the number in modulo P given as the input. Input The input consists of multiple datasets. Each dataset consists of a line with three integers A , B , and P separated by a space. These numbers satisfy the following conditions: 1 ≤ A ≤ 1,000,000,000, 0 ≤ B - A < 100,000, 1 ≤ P ≤ 1,000,000,000. The end of input is indicated by a line with three zeros. Output For each dataset, output the number of the subsets in modulo P . Sample Input 1 10 1000 1 100000 1000000000 999999999 1000099998 1000000000 0 0 0 Output for the Sample Input 513 899507743 941554688
[ { "submission_id": "aoj_2326_10858261", "code_snippet": "#include<cstdio>\n#include<iostream>\n#include<cstring>\n#include<algorithm>\nusing namespace std;\n#define lowbit(n) (n&-n)\nint l,r,m,a[100005],b,c[100005];\nvoid add(int pos,int val)\n{\n while(pos<=r-l+1) c[pos]=(c[pos]+val)%m,pos+=lowbit(pos...
aoj_2329_cpp
Problem J: Blue Forest John is playing a famous console game named 'Tales of Algorithmers.' Now he is facing the last dungeon called 'Blue Forest.' To find out the fastest path to run through the very complicated dungeon, he tried to draw up the dungeon map. The dungeon consists of several floors. Each floor can be described as a connected simple plane graph. Vertices of the graph are identified by X-Y coordinate, and the length of an edge is calculated by Euclidean distance. A vertex may be equipped with a one-way warp gate. If John chooses to use the gate, it brings John to another vertex in a possibly different floor. The distance between a warp gate and its destination is considered as 0. One vertex has at most one warp gate, though some vertices might be the destination of multiple warp gates. He believed he made one map for each floor, however after drawing maps of all the floors, he noticed that he might have made a few mistakes. He might have drawn the same floor several times, and might have forgotten to mark some warp gates in the maps. However, he was sure he marked all warp gates at least once. So if the maps of same floor are unified to one map, all the warp gates must be described there. Luckily there are no floors which have the same shape as the other floors, so if two (or more) maps can be unified, they must be the maps of the same floor. Also, there is no floor which is circular symmetric (e.g. a regular triangle and a square). Map A and map B can be unified if map B can be transformed to map A using only rotation and parallel translation. Since some of the warp gates on maps might be missing, you should not consider the existence of warp gates when checking unification. If it is possible to unify map A and map B, a vertex on map A and the corresponding vertex on map B are considered as 'identical' vertices. In other words, you should treat warp gates on map B as those on map A where the warp gates are located on the corresponding vertices on map A. Destinations of warp gates should be treated similarly. After that you can forget map B. It is guaranteed that if both map A and map B have warp gates which are on the identical vertices, the destinations of them are also identical. Remember, your task is to find the shortest path from the entrance to the exit of the dungeon, using the unified maps. Input The input consists of multiple datasets. Each dataset is in the following format. n component 1 component 2 ... component n sl sn dl dn n is a positive integer indicating the number of maps. component i describes the i -th map in the following format. A x 1 y 1 x 2 y 2 ... x A y A B s 1 d 1 s 2 d 2 ... s B d B C sn 1 dl 1 dn 1 sn 2 dl 2 dn 2 ... sn C dl C dn C A denotes the number of vertices in the map. Each of the following A lines contains two integers x i and y i representing the coordinates of the i -th vertex in the 2-dimensional plane. B denotes the number of the edges connecting the vertices in the map. Each of the following ...(truncated)
[ { "submission_id": "aoj_2329_2010618", "code_snippet": "#include<bits/stdc++.h>\n#define f first\n#define s second\n#define ff f,f\n#define fs f.s\n#define sf s.f\n#define ss s.s\n#define mp make_pair\n#define MAX 51\n#define inf 1e10\n#define eps (1e-11)\n#define pi M_PI\n#define equals(a,b) (fabs((a)-(b))...
aoj_2323_cpp
Problem D: Revenge of Champernowne Constant Champernowne constant is an irrational number. Its decimal representation starts with "0.", followed by concatenation of all positive integers in the increasing order. You will be given a sequence S which consists of decimal digits. Your task is to write a program which computes the position of the first occurrence of S in Champernowne constant after the decimal point. Input The input has multiple test cases. Each line of the input has one digit sequence. The input is terminated by a line consisting only of # . It is guaranteed that each sequence has at least one digit and its length is less than or equal to 100. Output For each sequence, output one decimal integer described above. You can assume each output value is less than 10 16 . Sample Input 45678 67891011 21 314159265358979 # Output for the Sample Input 4 6 15 2012778692735799
[ { "submission_id": "aoj_2323_9477278", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\nusing vll = vector<ll>;\n#define rep(i,n) for(ll i=0;i<ll(n);i++)\n#define all(A) A.begin(),A.end()\n\nll f(ll N) {\n if (N > 1e16)return 1e18;\n ll res = 0;\n ll d = 1;\n ...
aoj_2328_cpp
Problem I: Mobile Network The trafic on the Internet is increasing these days due to smartphones. The wireless carriers have to enhance their network infrastructure. The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f ( x ) of the year x . Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N -th base stations as a polynomial of x . Input The input consists of multiple datasets. Each dataset has the following format: N M u 1 v 1 p 1 ... u M v M p M The first line of each dataset contains two integers N (2 ≤ N ≤ 50) and M (0 ≤ M ≤ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i -th of them corresponds to the i -th network line and contains two integers u i and v i and a polynomial p i . u i and v i indicate the indices of base stations (1 ≤ u i , v i ≤ N ); p i indicates the network bandwidth. Each polynomial has the form of: a L x L + a L -1 x L -1 + ... + a 2 x 2 + a 1 x + a 0 where L (0 ≤ L ≤ 50) is the degree and a i 's (0 ≤ i ≤ L , 0 ≤ a i ≤ 100) are the coefficients. In the input, each term a i x i (for i ≥ 2) is represented as < a i > x ^< i > the linear term ( a 1 x ) is represented as < a 1 > x ; the constant ( a 0 ) is represented just by digits; these terms are given in the strictly decreasing order of the degrees and connected by a plus sign (" + "); just like the standard notations, the < a i > is omitted if a i = 1 for non-constant terms; similarly, the entire term is omitted if a i = 0 for any terms; and the polynomial representations contain no space or characters other than digits, "x", "^", and "+". For example, 2 x 2 + 3 x + 5 is represented as 2x^2+3x+5 ; 2 x 3 + x is represented as 2x^3+x , not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero. The end of input is indicated by a line with two zeros. This line is not part of any dataset. Output For each dataset, print the maximal bandwidth as a polynomial of x . The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes). Sample Input 3 3 1 2 x+2 2 3 2x+1 3 1 x+1 2 0 3 2 1 2 x 2 3 2 4 3 1 2 x^3+2x^2+3x+4 2 3 x^2+2x+3 3 4 x+2 0 0 Output for the Sample Input 2x+3 0 2 x+2
[ { "submission_id": "aoj_2328_10848629", "code_snippet": "#pragma comment(linker, \"/STACK:1024000000,1024000000\")\n#include <cstdio>\n#include <cmath>\n#include <cstring>\n#include <iostream>\n#include <queue>\n#include <map>\n#include <stack>\n#include <string>\n#include <algorithm>\n#include <vector>\n#i...
aoj_2331_cpp
Problem B: 友だちの誘い方 明日から、待ちに待った夏休みが始まります。なのでわたしは、友だちを誘って、海に遊びに行くこ とに決めました。 けれども、わたしの友だちには、恥ずかしがりやさんが多いです。その人たちは、あまり多くの人が いっしょに来ると知ったら、きっと嫌がるでしょう。 ほかにも、わたしの友だちには、目立ちたがりやさんも多いです。その人たちは、いっしょに来る人 があまり多くないと知れば、きっと嫌がるでしょう。 それと、わたしの友だちには、いつもは目立ちたがりやなのに実は恥ずかしがりやさんな人もいま す。その人たちは、いっしょに来る人が多すぎても少なすぎても、きっと嫌がるでしょう。 こういうのは、大勢で行った方が楽しいはずです。だからわたしは、できるだけたくさんの友だちを 誘いたいと思っています。けれども、嫌がる友だちを無理やり連れていくのはよくありません。 いったい、わたしは最大で何人の友だちを誘うことができるのでしょうか。 わたしは、こういう頭を使いそうな問題が大の苦手です。なので、あなたにお願いがあります。もし よろしければ、わたしの代わりにこの問題を解いていただけないでしょうか。いえ、決して無理にと は言いません。けれど、もし解いていただるのでしたら、わたしはとても嬉しいです。 Input N a 1 b 1 a 2 b 2 . . . a N b N 入力の１行目には、整数N（1 ≤ N ≤ 100,000）が書かれている。これは、友だちの数をあらわす。 続く N 行には、整数 a i と整数 b i （2 ≤ a i ≤ b i ≤ 100,001）が、空白区切りで書かれている。１＋ i 行目に書かれた整数 a i と b i は、i 番目の友だちは海に行く人数が a i 人以上 b i 人以下でないと嫌がることをあらわす。海に行く人数には「わたし」も含まれることに注意せよ。 Output 嫌がる友だちが出ないように、海に誘うことのできる友だちの最大人数を出力せよ。 Sample Input 1 4 2 5 4 7 2 4 3 6 Sample output 1 3 Sample Input 2 5 8 100001 7 100001 12 100001 8 100001 3 100001 Sample output 2 0 Sample Input 3 6 2 9 4 8 6 7 6 6 5 7 2 100001 Sample output 3 5
[ { "submission_id": "aoj_2331_10885637", "code_snippet": "#include<bits/stdc++.h>\n// #include<atcoder/all>\n// #include<boost/multiprecision/cpp_int.hpp>\n\nusing namespace std;\n// using namespace atcoder;\n// using bint = boost::multiprecision::cpp_int;\nusing ll = long long;\nusing ull = unsigned long lo...
aoj_2327_cpp
Problem H: Sky Jump Dr. Kay Em, a genius scientist, developed a new missile named "Ikan-no-i." This missile has N jet engines. When the i -th engine is ignited, the missile's velocity changes to ( vx i , vy i ) immediately. Your task is to determine whether the missile can reach the given target point ( X , Y ). The missile can be considered as a mass point in a two-dimensional plane with the y -axis pointing up, affected by the gravity of 9.8 downward (i.e. the negative y -direction) and initially set at the origin (0, 0). The engines can be ignited at any time in any order. Still, note that at least one of them needs to be ignited to get the missile launched. Input The input consists of multiple datasets. Each dataset has the following format. N vx 1 vy 1 vx 2 vy 2 ... vx N vy N X Y All values are integers and meet the following constraints: 1 ≤ N ≤ 1,000, 0 < vx i ≤ 1,000, -1,000 ≤ vy i ≤ 1,000, 0 < X ≤ 1,000, -1,000 ≤ Y ≤ 1,000. The end of input is indicated by a line with a single zero. Output For each dataset, output whether the missile can reach the target point in a line: " Yes " if it can, " No " otherwise. Sample Input 1 1 1 10 -480 2 6 7 5 5 4 1 3 10 5 4 4 8 4 2 0 0 Output for the Sample Input Yes Yes No
[ { "submission_id": "aoj_2327_10854011", "code_snippet": "#include <cstdio>\n#include <cstdlib>\n#include <cstring>\n#include <algorithm>\n\n#define MAXN 1005\n#define EPS 1e-8\n\nconst double g = 9.8;\n\nint n;\nstruct Point {\n\tdouble x, y;\n}p[MAXN];\ndouble X, Y;\n\nbool cmp(Point a, Point b) {\n\tretur...
aoj_2332_cpp
Problem 3: 時空のスゴロク・ロード 全時空統一ディメンション・スゴロク・トーナメント。500 兆人を超える参加者の中から、ただ１人 のスゴロク絶対王者を決定するその大会に、あなたは２１世紀の地球代表として参加している。 今あなたが挑戦している課題は、自分自身をコマとした１次元スゴロク。端のスタートマスから出発 して、１から６までの目が一つずつ書かれた巨大な６面ダイスを振って出た目の数だけ進むことを繰 り返す、あなたもよく知っている形式のスゴロクだ。スタートマスとは反対の端にあるゴールマスに 止まるとゴールとなる。もちろん、ゴールするまでにサイコロを振った回数が少なければ少ないほど 良い成績となる。 マスの中には特殊な効果を持ったマス「○マス進む」と「○マス戻る」が存在し、そこに止まってし まうと、指定されたマス数だけ進む、もしくは戻らなければならない。マスの効果で動いた結果、ふ たたび効果のあるマスに止まった場合は、続けて指示どおりに移動する。 しかし、これは一筋縄では攻略できない時空スゴロクだ。恐るべきことに、たとえば「３マス進む」 の３マス先に「３マス戻る」が置かれていることもありうる。このようなマスに止まり、マスの効果 で無限ループに陥ってしまった場合は、永遠にマスを往復し続けなければならない。 だが幸いなことに、あなたの身体には、望んだ事象を全事象に変えることのできる異能『確率湾曲』 が宿っている。この能力を使えば、サイコロの出目を自由に操ることも可能。このアドバンテージを 活かして、無限ループに陥らないようにしながら進んでいくとき、ゴールするまでにサイコロを振る 回数の最小値はいくつになるだろうか。 Input N p 1 p 2 . . . p N 入力の１行目には、整数 N （3 ≤ N ≤ 100,000）が書かれている。これは、スゴロクのマス数をあらわす。マスには1 番から N 番までの番号がふられている。スタートのマスが1 番で、それからスタートに近い順に2 番、3 番、……、 N - 1 番と続き、ゴールのマスが N 番である。 i 番のマスでサイコロを振ってj の目が出たら、 i + j 番のマスへと移動する。ただし、もしも i + j が N を超えていたら、余った数だけ戻ったりはせず、ゴールしたとみなされる。 続く N 行には、整数 p i （-100,000 ≤ p i ≤ 100,000）が書かれている。1 ＋ i 行目に書かれた整数 p i は、i 番のマスに書かれている指示をあらわす。 p i > 0 ならば「 p i マス進む」、 p i < 0 ならば「- p i マス戻る」であり、 p i = 0 ならばそのマスには何の効果もない。 p 1 と p N は必ず0 である。マスの効果で、スタートより前やゴールより後に移動しろと指示されることはない。 なお、与えられるスゴロクは、ゴールすることが可能であると仮定してよい。 Output ゴールするまでにサイコロを振る回数の最小値を出力せよ。 Sample Input 1 11 0 0 -2 0 -4 1 -1 2 0 0 0 Sample Output 1 3 Sample Input 2 12 0 0 7 0 2 0 0 3 -6 -2 1 0 Sample Output 2 1 Sample Input 3 8 0 4 -1 1 -2 -2 0 0 Sample Output 3 2
[ { "submission_id": "aoj_2332_9637294", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)\n#define rrep(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)\n#define ALL(v) (v).begin(), (v).end()\n#define UNIQUE(v) sort(ALL(v)...
aoj_2335_cpp
Problem F: １０歳の動的計画 ある日の夕方。いつものようにあなたが居間でテレビを見ていると、小学５年生の妹から相談を持ち かけられた。話を聞いてみると、今日学校で出された算数の問題が難しくて理解できなかったので、 あなたに解き方を教えてほしいのだという。 妹を悩ませている問題は、「道が碁盤目状に通っている街において、家(0, 0) から学校( N , M ) まで最短距離で進む方法は何通りあるか？」というものだった。もちろん、あなたにとっては赤子の手をひねるよりも簡単な問題である。すぐに上のような図を書いて「家(0, 0) から順番に足し算していけば解けるよ」と教えてあげた。 ところが、それを聞いてもまだ、妹はなにやら下を向いて考えこんでいる。あなたは、自分の説明の 仕方が悪かったのだろうかと思ったが、どうやらそうではないらしい。 たっぷり３分ほど悩んでいただろうか。妹は、おもむろに顔を上げると、あなたに向かってこう言っ た。 「でも、わたしだったら、きっと学校に行く途中で K 回くらい寄り道しちゃうだろうな……。ねぇお 兄ちゃん、そうすると答えは何通りになるの？」 さあ大変だ。兄の威厳を保つため、なんとしてもこの問題に答えねば。 この問題を定式化すると、次のようになる。 点(0, 0) から点( N , M ) まで、碁盤目状の道を通って進む方法は何通りあるか答えよ。 基本的には右か上に１マス進むが、途中で、ちょうど K 回だけ寄り道をする。 「寄り道をする」とは、左か下に１マス進むことである。 K 回の寄り道をすませていない場合、いったん点( N , M ) に着いた後でも歩き続ける。途中で点(0, 0) に戻ってくる場合もある。 家はこの街の隅に建っているので、X 座標またはY 座標が負になるような点に入ることはできない。 しかし、X 座標が N より大きな点、または、Y 座標が M より大きな点には入ることができる。 Input N M K 入力の１行目には、整数N（1 ≤ N ≤ 100,000）と整数M（1 ≤ M ≤ 100,000）と整数 K （0 ≤ K ≤ 10,000）が、この順に空白区切りで書かれている。整数 N は学校のX 座標を、整数 M は学校のY座標を、整数 K は寄り道の回数をあらわす。 Output 点(0, 0) から点( N , M ) まで、 K 回の寄り道をして進む方法。その総数を1,000,000,007 で割った余りを出力せよ。なお1,000,000,007 は素数である。 Sample Input 1 6 4 0 Sample Output 1 210 Sample Input 2 3 3 1 Sample Output 2 448 Sample Input 3 124 218 367 Sample Output 3 817857665
[ { "submission_id": "aoj_2335_9770269", "code_snippet": "#line 2 \"cp-library/src/cp-template.hpp\"\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\nusing ld = long double;\nusing uint = unsigned int;\nusing ull = unsigned long long;\nusing i32 = int;\nusing u32 = unsigned int;\nusing...
aoj_2334_cpp
Problem E: 街を駆ける道 ネーヴァ王国には、トタタ族とツテテ族、２種類の民族が暮らしている。トタタ族の最大の特徴は、 酢豚にパイナップルを入れて食べることである。だがツテテ族は、パイナップルに酢豚を入れて食べ る。こんな２つの民族がお互いに仲良くやっていけるはずもなく、トタタ族とツテテ族は、何百年も の昔からずっといがみ合いを続けてきた。 そんなある日、ネーヴァ王のもとに、２つの民族から嘆願書が届いた。それによるとトタタ族は、自 分たちが暮らす街Ａと街Ｂのあいだを結ぶ道を建設してほしいらしい。一方でツテテ族も、自分たち が暮らす街Ｃと街Ｄのあいだを結ぶ道を建設してほしいらしい。 ２つの民族が衝突するのを防ぐため、トタタ族が通る道とツテテ族が通る道を交差させることはでき ない。また、技術的な制約により、２つの街のあいだを一直線に結ぶような道しか建設することはで きない。つまり、必要ならば街Ａと街Ｂを直接道で結ばずに、いくつかのトタタ族の街を経由して街 Ａと街Ｂを間接的に結ぶことになるだろう（もちろん、ツテテ族の街を経由してはならない）。その 際、トタタ族の街を結ぶ道どうしは交差していてもよい。街Ｃと街Ｄについても同様である。 道を建設するには、その長さに比例したコストがかかる。なので、条件をみたしつつ、できるだけ建 設する道の長さの合計が短くなるようにしたい。さて、長さの最小値はいくつになるだろうか。 Input N A N B x A ,1 y A ,1 x A ,2 y A ,2 . . . x A , N A y A , N A x B ,1 y B ,1 x B ,2 y B ,2 . . . x B , N B y B , N B 入力の１行目には、整数 N A （2 ≤ N A ≤ 1,000）と整数 N B （2 ≤ N B ≤ 1,000）が、空白区切りで書かれている。これは、ネーヴァ王国にはトタタ族が暮らす街がNA 個、ツテテ族が暮らす街がNB 個あることをあらわす。初期状態では、どこにも道は建設されていない。 続く N A 行には、整数 x A,i （-10,000 ≤ x A,i ≤ 10,000）と整数 y A,i （-10,000 ≤ y A,i ≤ 10,000）が、空白区切りで書かれている。ネーヴァ王国の地理は２次元直交座標平面であらわされ、１＋ i 行目に書かれた整数 x A,i と y A,i は、トタタ族が暮らすi 番目の街の位置座標が( x A,i , y A,i ) であることをあらわす。( x A,1 , y A,1 ) と( x A,2 , y A,2 ) が、結ぶべき２つの街の座標である。 続く N B 行には、整数 x B,i （-10,000 ≤ x B,i ≤ 10,000）と整数 y B,i （-10,000 ≤ y B,i ≤ 10,000）が、空白区切りで書かれている。１＋ N A ＋ i 行目に書かれた整数 x B,i と y B,i は、ツテテ族が暮らすi 番目の街の位置座標が( x B,i , y B,i ) であることをあらわす。( x B,1 , y B,1 ) と( x B,2 , y B,2 ) が、結ぶべき２つの街の座標である。 どの２つの街の座標も異なっており、どの３つの街も同一直線上にないと仮定してよい。 Output 問題文の条件をみたすように道を建設したとき、道の長さの合計の最小値を出力せよ。ここで言う 「長さ」とは、ユークリッド距離のことである。ただし、どうやっても条件をみたす道を建設できな いときは、代わりに-1 を出力せよ。出力は誤差を含んでいてもよいが、真の値との相対誤差が10 -9 未満でなければならない。 Sample Input 1 2 2 0 0 1 1 2 0 2 -1 Sample Output 1 2.414213562373 Sample Input 2 2 3 4 0 0 0 2 3 2 -2 3 1 Sample Output 2 -1 Sample Input 3 5 2 -2 1 1 2 -1 3 -1 5 1 4 0 4 0 0 Sample Output 3 12.359173603117
[ { "submission_id": "aoj_2334_10880844", "code_snippet": "#include <bits/stdc++.h>\n#define rep(i,n) for(int i = 0; i < (n); i++)\nusing namespace std;\ntypedef long long ll;\n\nusing Real = double;\nusing Point = complex< Real >;\nusing Polygon = vector< Point >;\nconst Real EPS = 1e-9, PI = acos(-1);\ncons...
aoj_2337_cpp
Problem H: ねこ鍋改造計画（仮） あなたは、自宅にたくさんのねこを飼っている。そんなあなたの日課は、飼っているねこが土鍋の中 に入って昼寝している様子（通称：ねこ鍋）を撮影することだ。何匹かのねこが、鍋の中でいっしょ に丸くなって眠る姿は、実に愛くるしい。 それぞれのねこには、「重さ」 m i と「Cute」 c i が定義されている。Cute とは、そのねこ1 匹だけを見たときの、愛らしさ・あどけなさ・しなやかさ・やわらかさ・ういういしさ、などを総合的に評価した数値であり、大きければ大きいほどそのねこは魅力的である。 また、ねこ鍋に対しては「UnCute」という数値が定義される。これは、ねこ鍋全体としてのアンバラ ンスさをあらわす値であり、Cute とは逆に、小さければ小さいほど、そのねこ鍋はよいねこ鍋であ る。ねこ鍋のUnCute は、中にいるねこのCute の最大値 C max と最小値 C min を用いて、 C max - C min とあらわされる。つまり、中にいるねこがみな同じくらいのCute を持っているねこ鍋が、よいねこ鍋である。 ねこ鍋を持ち運ぶときのことを考えると、ねこ鍋の重さ（＝中にいるねこの重さの総和）は、限界値 W 以下でなければならない。この条件をみたすようにねこ鍋に入ってもらうねこを選んで、ねこ鍋のUnCute を小さくしたいのだが、いったいどこまで小さくできるのだろうか。 ……という問題を解いてすっかり満足した気になっていたのは、過去の話だ。 この前、あなたが家の倉庫を整理していたら、倉庫の中から古ぼけた土鍋が見つかった。これであな たの家にある土鍋は２つ。そう、これからは、デュアルねこ鍋の時代なのだ！　ただのねこ鍋なども う古い！ デュアルねこ鍋では、土鍋 A はオスのねこ専用、もう片方の土鍋B はメスのねこ専用である。また、 デュアルねこ鍋のUnCute を定義するにあたっては、Cute のアンバランスさだけではなく、２つの ねこ鍋の重さのアンバランスさも考慮に入れる必要がある。具体的には、重いほうのねこ鍋の重さを M max 、軽いほうのねこ鍋の重さを M min とおくと（２つのねこ鍋の重さが同じときは M max = M min ）、デュアルねこ鍋のUnCute は、 max{ M max - M min , C max - C min } とあらわされる。なお、ここでの C max と C min は、ねこ鍋 A の中またはねこ鍋 B の中にいるねこのCute の最大値,最小値である。 ねこ鍋を持ち運ぶときのことを考えると、 M max は、限界値 W 以下でなければならない。この条件をみたすようにデュアルねこ鍋に入ってもらうねこを選んで、デュアルねこ鍋のUnCute を小さくしたいのだが、いったいどこまで小さくできるのだろうか。 Input N A N B W m A ,1 c A ,1 m A ,2 c A ,2 . . . m A , N A c A , N A m B ,1 c B ,1 m B ,2 c B ,2 . . . m B , N B c B , N B 入力の１行目には、整数 N A （1 ≤ N A ≤ 500）と整数 N B （1 ≤ N B ≤ 500）と整数 W （1 ≤ W ≤ 10,000）が、空白区切りで書かれている。これは、あなたが飼っているオスのねこが全部で N A 匹、メスのねこが全部で N B 匹いることをあらわす。 W はねこ鍋の重さの限界値である。 続く N A 行には、整数 m A , i （1 ≤ m A , i ≤ 10,000）と整数 c A , i （1 ≤ c A , i ≤ 1,000,000,000）が、空白区切りで書かれている。１＋ i 行目に書かれた整数 m A , i と c A , i は、i 番目のオスのねこの重さが m A , i 、Cute が c A , i であることをあらわす。 続く N B 行には、整数 m B , i （1 ≤ m B , i ≤ 10,000）と整数 c B , i （1 ≤ c B , i ≤ 1,000,000,000）が、空白区切りで書かれている。１＋ N A ＋ i 行目に書かれた整数 m B , i と c B , i は、i 番目のメスのねこの重さが m B , i 、Cute が c B , i であることをあらわす。 オスのねこにもメスのねこにも、重さが W 以下であるようなねこが、それぞれ１匹以上は存在すると仮定してよい。 Output M max が W を超えないという条件のもとで、デュアルねこ鍋のUnCute の最小値を出力せよ。ただし、どちらのねこ鍋にも１匹以上のねこが入っていなければならない。 Sample Input 1 4 3 12 3 6 2 4 7 9 10 1 6 5 8 4 15 19 Sample Output 1 2 Sample Input 2 1 3 10 1 15 6 8 5 9 8 7 Sample Output 2 6 Sample Input 3 8 6 65 30 98 27 51 4 74 65 87 49 19 27 48 43 7 35 28 43 69 8 47 64 75 18 23 54 29 40 43 Sample Output 3 8
[ { "submission_id": "aoj_2337_10292218", "code_snippet": "// AOJ #2337 Remodeling Plan for Neko-Nabe (tentative)\n// 2025.3.13\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\nstruct BS {\n int sz, nw;\n vector<ll> d;\n BS(int s) : sz(s), nw((s+63)/64) { d.assign(nw,0ULL);...
aoj_2339_cpp
Problem J: 問題文担当者は働かない！ N 個の点からなる有向グラフがある。このグラフに閉路はない。それぞれの点には、いくつかの石が置かれている。このグラフを使って、２人のプレイヤーがゲームをする。おのおのの手番は、交互に訪れる。各プレイヤーは、自分の手番において、頂点 v を選び、そこに置かれた石を１つ以上取り除く。その後、 v から w に辺が張られているすべての頂点 w について、 w に置かれている石の個数を自由に変化させることができる（いくつ増やしても、いくつ減らしても、変化させなくてもよい）。これを繰り返して、最初に取る石がなくなった方の負けである。両者が最善をつくしたとき、先手と後手、どちらが勝つか。もしくは、いつまでもゲームが終わらないか。 「……いや、無理でしょう、これ」 「何が？」 「何がじゃなくて！　これにどうやって自然な問題設定をつけろって言うんですか」 「ははは。それを考えるのが君の仕事じゃないか。文章担当だろう？」 「丸投げにもほどがありますよ……。まずゲームのルールが不自然すぎるでしょう」 「そうかなぁ？　僕はよくある石取りゲームだと思うけどね」 「プレイヤーの意思で石を無尽蔵に増やせる石取りゲームがよくあってたまりますか！」 「お。君、今うまいこと言ったね」 「ええ、意思で石を……ってどうでもいいわ！　そっちも少しは考えてくださいよ」 「そうだねぇ。縊死した医師の遺志を継ぐ遺子の意思で石を取る、なんてどうだい？」 「考えるのはそこじゃねぇよ！　石取りゲームの話だよ！」 「違うのかい？　でも『取り』は鳥くらいしか同音異義語がなくて難しいんだよね」 「いったん言葉遊びから離れろや！　自然な問題設定を考えてくれって言ってるんですよ！」 「だからそれは君の仕事だろうに。僕はただの仲介役。原案担当と文章担当の間をとりもつだけさ」 「くそ……。原案担当め、どうしてこんな厄介な問題を……」 「原案担当者から君へのメッセージ。『フヒヒｗ　存分に苦しめ文章担当ｗｗ』だそうだよ」 「畜生あの野郎！　いつか一発殴る！」 「まあ、僕の『石が増える石取りゲームなんて実に設定がつけにくいと思わないかい？』ってアドバ イスのおかげもあるだろうけどね」 「畜生お前もか！　いつかと言わず今殴る！」 「はっはっは。君が締め切りまでに文章担当としての役割を果たせないようなら、僕が勝手に問題文 を書いちゃうよ？」 「殴……って、え？　お前が書いてくれんの？」 「タイトルは『問題文担当者は働かない！』。本文には、僕たちのこの会話をそのまま掲載」 「頼むからやめて！　そんなふざけた問題が自分名義で世に出たら、これから皆になんて言われる か！」 「はっはっは。締め切りも守れないような奴は、社会的に抹殺されて当然だよね」 「畜生！　こうなったら、意地でも自然な問題設定を思いついてやらあああああ！」 （※　結局そのまま掲載されました） Input N M v 1 v 2 . . . v N a 1 b 1 a 2 b 2 . . . a M b M 入力の１行目には、整数 N （2 ≤ N ≤ 1,000）と整数 M （1 ≤ M ≤ 10,000）が、空白区切りで書かれている。これは、有向グラフがN 個の点と M 本の辺からなることをあらわす。頂点には、1 番から N 番までの番号がふられている。 続く N 行には、整数 v i （1 ≤ v i ≤ 10,000）が書かれている。１＋ i 行目に書かれた整数 v i は、i 番の点に最初はvi 個の石が置かれていることをあらわす。 続く M 行には、整数 a i （1 ≤ a i ≤ N ）と整数 b i （1 ≤ b i ≤ N ）が、空白区切りで書かれている。１＋ N ＋ i 行目に書かれた整数 a i と b i は、 a i 番の点から b i 番の点へ張られている辺が存在することをあらわす。ある点から自分自身へと張られる辺は存在せず、ある点A からある点B へ張られる辺は高々１本である。 与えられた有向グラフには閉路がないと仮定してよい。 Output 両プレイヤーが自身の勝利を目指して最善をつくしたとき、先手が勝つならば1 を、後手が勝つなら ば2 を、いつまでもゲームが終わらないならば0 を出力せよ。 Sample Input 1 6 5 7 14 5 11 2 5 1 2 2 3 3 4 4 5 5 6 Sample Output 1 2 Sample Input 2 5 7 295 127 350 982 426 1 5 3 5 4 2 3 1 3 4 5 4 3 2 Sample Output 2 1 Sample Input 3 8 7 6 1 7 2 5 2 6 3 1 3 6 3 7 4 4 2 1 6 5 4 7 5 Sample Output 3 2
[ { "submission_id": "aoj_2339_1712886", "code_snippet": "#define _USE_MATH_DEFINES\n#include <algorithm>\n#include <cstdio>\n#include <functional>\n#include <iostream>\n#include <cfloat>\n#include <climits>\n#include <cstdlib>\n#include <cstring>\n#include <cmath>\n#include <map>\n#include <queue>\n#include ...
aoj_2338_cpp
Problem I: よくわかる二重魔法 紀慧暦2119 年15 の月。宮廷魔術士Sengemon Lugene の手によって、一冊の魔術書が書き記された。この魔術書「In Magiray」は、この世界の魔術法則の根幹に深く関わる「二重魔法」を、誰にでも習得可能な技術として体系化した、という点で革新的な書物であった。まずは、この書物の内容を要約したものを見ていこう。 【エレメント】 世界中のあらゆる物体は、「泉」「風」「羽」「花」「砂」「灯」……といった、極小要素「エレメント」から構成されている。エレメントには多くの種類があり、人間はエレメントと契約を交わすことで、契約を交わした種類のエレメントを用いた二重魔法を発動させることができる。 【二重魔法】 二重魔法とは、その名の通り、２つのエレメントを重ね合わせて解き放つ魔法である。主となるエレ メントを「主属性」、もう一方を「副属性」と呼ぶ。たとえば、主属性が「灯」で副属性が「花」な ら、その二重魔法は（灯，花）と表記される。（灯，花）と（花，灯）は別の二重魔法である。また、主属性と副属性は同じであってもよい。 【キーワード】 「泉→ huda」「風→ loar」「羽→ sheza」「花→ leide」といったように、各々のエレメントに、それぞれ短い「キーワード」を１対１対応させることができる。キーワードは、エレメントの持つ性質を短い言葉に象徴させることで、いくつかの連続するキーワード列を唱えるだけで簡単に二重魔法を発動させることを可能にした、画期的な概念である。 【呪文】 「huda・leide・loar・sheza」のように、１つ以上のキーワードを連続して並べたものを「呪文」という。術者が意図した呪文を唱えることで、対応する二重魔法を発動させることができる。具体的には、呪文の一番最初のキーワードに対応するエレメントを主属性、一番最後のキーワードに対応するエレメントを副属性とする二重魔法が発動する。先ほどの呪文の例だと、発動する二重魔法は（泉，羽）である。なお、呪文が１つのキーワードだけから成る場合には、主属性も副属性も、そのキーワードに対応するエレメントになる。 【エレメント同士の相性】 「huda・leide・loar・sheza」の呪文で（泉，羽）の二重魔法が発動することはすでに述べた。しかし、一見すると、（泉，羽）を使いたいのならば、わざわざ長い呪文を唱えずとも「huda・sheza」だけで良いようにも思える。だが実際には、それは不可能である。なぜなら、「泉（huda）」と「羽（sheza）」は相性が良くないため、これら２つが隣り合った呪文を唱えると、反発作用が起こってエレメント同士が相殺してしまうからである。一方で、「泉（huda）」と「花（leide）」、「花（leide）」と「風（loar）」、「風（loar）」と「羽（sheza）」は、どのペアも好相性なので、「huda・leide・loar・sheza」や「loar・leide・huda」といった呪文では、エレメントの相殺は起こらない。 【呪文論理】 二重魔法を使おうとする者は、あらかじめ、すべての好相性なエレメントのペアそれぞれに対して、 どちらのキーワードが「上位ワード」で、どちらのキーワードが「下位ワード」なのかを定義しておかなければならない。好相性な２つのエレメントのキーワード「 A 」と「 B 」に対して、 A を上位ワード、 B を下位ワードと定義したとき、 A > B と表記する。 A > B であるとき、一つの呪文内で、 B の直後に A を並べることはできない。つまり、「 A 1 ・ A 2 ・ A 3 ・……・ A k 」が正しい呪文であるならば、 A 1 > A 2 ， A 2 > A 3 ，……， A k -1 > A k でなくてはならない。ちなみに、 A > B かつ B > C であっても、 A > C である必要はない。 このように、各々の術者が、上位・下位ワードを自分好みに定義することを「呪文論理の構築」と呼 ぶ。これは、あえて呪文の構文に制約をもたせることで、エレメントの流れを明確化し、目的の二重 魔法の成功確率を上げるための工夫である。だが、その代償として、呪文論理を構築すると、どのよ うに呪文を唱えても発動させることのできない二重魔法が生じてしまう可能性がある（ただし、いか なる呪文論理を構築しても使うことのできない二重魔法は存在しないことが証明されている）。この ような事情があるため、どのような呪文論理を構築するかは、今も昔も多くの魔術士を悩ませている 厄介な問題なのである。 とある小さな町で暮らす見習い魔術士の少年ユートは、すべてのエレメントとの契約を終え、いよい よ明日、自分の呪文論理を構築するための儀式を行おうとしている。ユートは単純に、できるだけた くさんの種類の二重魔法を発動させることができるような呪文論理が良い呪文論理である、と考えて いた。 超一級電術技師（現代日本で言うところのスーパープログラマー）であるあなたは、友達のユートか ら、うまく呪文論理を構築することができれば、最大で何種類の二重魔法を使えるようになるのか知 りたいと相談を受けた。これは、今まで世界中の人間が挑戦してきたが、誰も解くことができなかっ たほどの難問である。もしも解くことができれば、あなたの名前は未来永劫、世界中で語り継がれる ことになるであろう。 Input N M s 1 s 2 . . . s N p 1 q 1 p 2 q 2 . . . p M M 入力の１行目には、整数 N と整数 M が、空白区切りで書かれている。これは、エレメントが全部で N 種類、好相性なエレメントのペアが全部で M 組存在することをあらわす。 続く N 行には、１つの文字列が書かれている。１＋ i 行目に書かれた文字列 s i は、i 番目のエレメントに対応するキーワードが s i であることをあらわす。 続くM 行には、２つの文字列が空白区切りで書かれている。１＋ N ＋ i 行目に書かれた文字列 p i と q i は、キーワード p i に対応するエレメントと、キーワード q i に対応するエレメントのペアが、好相性であることをあらわす。逆に、ここにあらわれなかったエレメントのペアは、好相性ではない。 これらのデータは、以下の条件をみたす。 2 ≤ N ≤ 100 1 ≤ M ≤ 4,950 s i は、アルファベットの大文字または小文字のみからなる、1 文字以上15 文字以下の文字列 i ≠ j ⇒ s i ≠ s j p i ≤ q i i ≤ j ⇒　( p i , q i ) ≠ ( p j , q j ) かつ( p i , q i ) ≠ ( q j , p j ) いかなる呪文論理を構築しても発動することのできない二重魔法は存在しない Output 呪文論理を構築したとき、使用可能になる二重魔法の種類の最大数を出力せよ。 Sample Input 1 4 3 huda leide loar sheza huda leide leide ...(truncated)
[ { "submission_id": "aoj_2338_8283689", "code_snippet": "#include <iostream>\n#include <vector>\nusing namespace std;\n\nclass UnionFind {\npublic:\n\tvector<int> par;\n\n\tvoid init(int sz) {\n\t\tpar.resize(sz, -1);\n\t}\n\n\tint root(int pos) {\n\t\tif (par[pos] == -1) return pos;\n\t\tpar[pos] = root(par...
aoj_2336_cpp
Problem G: スプリング・タイル ある朝、あなたが目覚めると、そこはバネだらけの迷宮の中だった。 なぜ自分がこんな見知らぬ場所にいるのかはわからない。この場でじっと助けを待つという選択肢も あるにはあるが、こういった迷宮の中に長居していると、いつかは必ず突風が吹いてきて吹き飛ばさ れてしまうことを、あなたは経験上知っていた。しかし、突風が吹いてくるまでの時間は判断のしよ うがない。そこであなたは、迷宮から脱出するまでに必要な移動回数の期待値が最小になるように行 動するのが最善の戦略だと考えた。 足元に落ちていた正体不明の巻物を拾ってためしに読んでみたところ、偶然にも迷宮の全体マップを 知覚することができた。さらに、たまたま持っていた草を飲むことで、すべてのワナの位置も知るこ とができた。どうやらこの迷宮には、危険なモンスターやバネ以外のワナは存在しないらしい。 この迷宮は、いくつかの種類のタイルが長方形に並んだ形をしており、たとえば以下のようにあらわ される。 ######## #..##g.# #*#.*#.# #......# #*s#*.*# ######## 「.」：床。この上なら自由に歩き回ることができる。 「#」：壁。あなたは壁の中に入ることはできない。 「s」：あなたの最初の位置。このタイルの下は床になっている。 「g」：階段。このタイルの上に乗れば、迷宮を脱出したことになる。 「*」：バネ。このタイルの上に乗ると、いずれかの床の上（階段、バネのタイルは除く）にランダムに飛ばされる。それぞれの床に飛ばされる確率はすべて等しい。 タイルの種類は、この５つのいずれかである。 あなたは、現在乗っているタイルから隣り合ったタイルへ、上下左右いずれかの方向に１マスずつ移 動することができる。ただし、ナナメに移動することはできない。 迷宮のマップが与えられたとき、最善の戦略をとった場合に迷宮から脱出するまでに必要な移動回数 の期待値を求めよ。バネで飛ばされるのは移動回数には含めない。 Input W H c 11 c 12 ... c 1 w c 21 c 22 ... c 2 w ::    : c h 1 c h 2 ... c c w 入力の１行目には、整数 W （3 ≤ W ≤ 500）と整数 H （3 ≤ H ≤ 500）が、この順に空白区切りで書かれている。整数 W は迷宮の横幅を、整数 H は迷宮の縦幅をあらわす。 続く H 行には、迷宮のマップをあらわす W 個の文字が書かれている（空白区切りではない）。この部分の形式は、先に挙げた例のとおりである。なお、データ中に「s」と「g」は、それぞれちょうど１回ずつ出現する。また、迷宮の周囲１マスは、必ず壁で囲まれている。 なお、与えられる迷宮では、どのように移動し、バネでどのように飛ばされたとしても、「バネで飛 ばされる床を任意に設定できたとしても脱出不可能な状態」に陥ることはないと仮定してよい。 Output 最善の戦略をとったときに、脱出までにかかる移動回数の期待値を出力せよ。出力は誤差を含んでい てもよいが、真の値との相対誤差が10 -9 未満でなければならない。 Sample Input 1 8 6 ######## #..##g.# #*#.*#.# #......# #*s#*.*# ######## Sample Output 1 5.857142857143 Sample Input 2 21 11 ##################### #*#*.*.*.*.*.*.*.*#*# #*#...............#*# #*#.#.#.#.#.#.#.#.#*# ##.#.#.#.#.#.#.#.#.## #...................# ##.#.#.#.#.#.#.#.#.## #s#.#.#.#.#.#.#.#.#g# #...................# #...................# ##################### Sample Output 2 20.000000000000 Sample Input 3 9 8 ######### #...#*.*# #.*.#...# #...#*.*# ######### #.s....g# #.*#.*..# ######### Sample Output 3 5.000000000000
[ { "submission_id": "aoj_2336_10880834", "code_snippet": "#include <queue>\n#include <string>\n#include <iomanip>\n#include <iostream>\n#pragma warning(disable : 4996)\nusing namespace std;\nstruct state {\n\tint x, y; long double dist;\n};\nbool operator<(const state& s1, const state& s2) {\n\treturn s1.dis...
aoj_2340_cpp
Carpenters' Language International Carpenters Professionals Company (ICPC) is a top construction company with a lot of expert carpenters. What makes ICPC a top company is their original language. The syntax of the language is simply given in CFG as follows: S -> SS | (S) | )S( | ε In other words, a right parenthesis can be closed by a left parenthesis and a left parenthesis can be closed by a right parenthesis in this language. Alex, a grad student mastering linguistics, decided to study ICPC's language. As a first step of the study, he needs to judge whether a text is well-formed in the language or not. Then, he asked you, a great programmer, to write a program for the judgement. Alex's request is as follows: You have an empty string S in the beginning, and construct longer string by inserting a sequence of '(' or ')' into the string. You will receive q queries, each of which consists of three elements (p, c, n) , where p is the position to insert, n is the number of characters to insert and c is either '(' or ')', the character to insert. For each query, your program should insert c repeated by n times into the p -th position of S from the beginning. Also it should output, after performing each insert operation, "Yes" if S is in the language and "No" if S is not in the language. Please help Alex to support his study, otherwise he will fail to graduate the college. Input The first line contains one integer q ( 1 \leq q \leq 10^5 ) indicating the number of queries, follows q lines of three elements, p_i , c_i , n_i , separated by a single space ( 1 \leq i \leq q , c_i = '(' or ')' , 0 \leq p_i \leq length of S before i -th query, 1 \leq n \leq 2^{20} ). It is guaranteed that all the queries in the input are valid. Output For each query, output "Yes" if S is in the language and "No" if S is not in the language. Sample Input 1 3 0 ( 10 10 ) 5 10 ) 5 Output for the Sample Input 1 No No Yes Sample Input 2 3 0 ) 10 10 ( 5 10 ( 5 Output for the Sample Input 2 No No Yes Sample Input 3 3 0 ( 10 10 ) 20 0 ( 10 Output for the Sample Input 3 No No Yes
[ { "submission_id": "aoj_2340_10728160", "code_snippet": "#include <stdio.h>\n#include <string.h>\n#include <math.h>\n#include <stdlib.h>\n#define N 100000\n#define ll long long\n#define clr(xx,yy) memset(xx,yy,sizeof(xx))\nll a[N],b[N];\nint main()\n{\n long long i,j,n,m,k,t,tt,max,maxn,p,T;\n char c...
aoj_2333_cpp
Problem D: 僕の友達は小さい 僕には、たくさんの友達がいる。どの友達も、とても小さい。 僕は、よく友達と一緒に出かける。何人かの友達をリュックに入れて、一緒に出かける。 僕は毎朝、その日一緒に出かける友達を決める。空のリュックに、１人ずつ友達を入れていく。 僕は、あまり力が強くない。だから、同時に運べる友達の重さには限界がある。 僕は、重さの限界を超えないように友達を入れていく。どの順番で入れていくかは気分次第。 僕は、入れられる友達がまだ残っている限り、入れるのを止めない。決して止めない。 ……ところで、リュックに入った友達の組み合わせは、全部で何パターンあるんだろう？ Input N W w 1 w 2 . . . w n 入力の１行目には、整数 N （1 ≤ N ≤ 200）と整数 W （1 ≤ W ≤ 10,000）が、この順に空白区切りで書かれている。整数 N は友達の数を、整数 W は同時に運べる重さの限界をあらわす。重さの合計が W より大きいと運ぶことはできない。 続く N 行には、友達の重さをあらわす整数が書かれている。整数 w i （1 ≤ w i ≤ 10,000）が、 i 番目の友達の重さをあらわす。 Output 最終的にリュックに入っている友達の組み合わせは何通り考えられるか。その総数を1,000,000,007 で割った余りを出力せよ。なお1,000,000,007 は素数である。 「誰もリュックに入っていない」も１通りとして数えることに注意せよ。 Sample Input 1 4 8 1 2 7 9 Sample Output 1 2 Sample Input 2 4 25 20 15 20 15 Sample Output 2 4 Sample Input 3 6 37 5 9 13 18 26 33 Sample Output 3 6
[ { "submission_id": "aoj_2333_10880846", "code_snippet": "#include <vector>\n#include <iostream>\n#include <algorithm>\n#include <functional>\nusing namespace std;\nconst int mod = 1000000007;\nint N, W;\nint main() {\n\tcin >> N >> W;\n\tvector<int> a(N);\n\tfor (int i = 0; i < N; i++) cin >> a[i];\n\tsort(...
aoj_2343_cpp
Matrix Operation You are a student looking for a job. Today you had an employment examination for an IT company. They asked you to write an efficient program to perform several operations. First, they showed you an N \times N square matrix and a list of operations. All operations but one modify the matrix, and the last operation outputs the character in a specified cell. Please remember that you need to output the final matrix after you finish all the operations. Followings are the detail of the operations: WR r c v (Write operation) write a integer v into the cell (r,c) ( 1 \leq v \leq 1,000,000 ) CP r1 c1 r2 c2 (Copy operation) copy a character in the cell (r1,c1) into the cell (r2,c2) SR r1 r2 (Swap Row operation) swap the r1-th row and r2-th row SC c1 c2 (Swap Column operation) swap the c1-th column and c2-th column RL (Rotate Left operation) rotate the whole matrix in counter-clockwise direction by 90 degrees RR (Rotate Right operation) rotate the whole matrix in clockwise direction by 90 degrees RH (Reflect Horizontal operation) reverse the order of the rows RV (Reflect Vertical operation) reverse the order of the columns Input First line of each testcase contains nine integers. First two integers in the line, N and Q, indicate the size of matrix and the number of queries, respectively (1 \leq N,Q \leq 40,000) . Next three integers, A B, and C, are coefficients to calculate values in initial matrix (1 \leq A,B,C \leq 1,000,000) , and they are used as follows: A_{r,c} = (r * A + c * B) mod C where r and c are row and column indices, respectively (1\leq r,c\leq N) . Last four integers, D, E, F, and G, are coefficients to compute the final hash value mentioned in the next section (1 \leq D \leq E \leq N, 1 \leq F \leq G \leq N, E - D \leq 1,000, G - F \leq 1,000) . Each of next Q lines contains one operation in the format as described above. Output Output a hash value h computed from the final matrix B by using following pseudo source code. h <- 314159265 for r = D...E for c = F...G h <- (31 * h + B_{r,c}) mod 1,000,000,007 where "<-" is a destructive assignment operator, "for i = S...T" indicates a loop for i from S to T (both inclusive), and "mod" is a remainder operation. Sample Input 1 2 1 3 6 12 1 2 1 2 WR 1 1 1 Output for the Sample Input 1 676573821 Sample Input 2 2 1 3 6 12 1 2 1 2 RL Output for the Sample Input 2 676636559 Sample Input 3 2 1 3 6 12 1 2 1 2 RH Output for the Sample Input 3 676547189 Sample Input 4 39989 6 999983 999979 999961 1 1000 1 1000 SR 1 39989 SC 1 39989 RL RH RR RV Output for the Sample Input 4 458797120
[ { "submission_id": "aoj_2343_10848580", "code_snippet": "#include <cstdio>\n#include <cstdlib>\n#include <cstring>\n#include <map>\n\nusing namespace std;\n\nconst int maxn=4e4+5;\n\nbool RH,RV,R;\nint row[maxn],colum[maxn];\nint A,B,C,D,E,F,G,n,q;\n\nstruct HashMap\n{\n int mod;\n int begin[100007],n...
aoj_2341_cpp
Kth Sentence A student, Kita_masa, is taking an English examination. In this examination, he has to write a sentence of length m . Since he completely forgot the English grammar, he decided to consider all sentences of length m constructed by concatenating the words he knows and write the K -th sentence among the candidates sorted in lexicographic order. He believes that it must be the correct sentence because K is today's lucky number for him. Each word may be used multiple times (or it's also fine not to use it at all) and the sentence does not contain any extra character between words. Two sentences are considered different if the order of the words are different even if the concatenation resulted in the same string. Input The first line contains three integers n ( 1 \leq n \leq 100 ), m ( 1 \leq m \leq 2000 ) and K ( 1 \leq K \leq 10^{18} ), separated by a single space. Each of the following n lines contains a word that Kita_masa knows. The length of each word is between 1 and 200, inclusive, and the words contain only lowercase letters. You may assume all the words given are distinct. Output Print the K -th (1-based) sentence of length m in lexicographic order. If there is no such a sentence, print "-". Sample Input 1 2 10 2 hello world Output for the Sample Input 1 helloworld Sample Input 2 3 3 6 a aa b Output for the Sample Input 2 aba Sample Input 3 2 59 1000000000000000000 a b Output for the Sample Input 3 -
[ { "submission_id": "aoj_2341_10848657", "code_snippet": "#include <cstdio>\n#include <cstring>\n#include <algorithm>\n#include <vector>\n#include <string>\n#include <map>\n#include <set>\n#include <queue>\n#include <cmath>\n#include <iostream>\n#include <cstdlib>\n#include <sstream>\n\nusing namespace std;\...
aoj_2345_cpp
Network Reliability An undirected graph is given. Each edge of the graph disappears with a constant probability. Calculate the probability with which the remained graph is connected. Input The first line contains three integers N ( 1 \leq N \leq 14 ), M ( 0 \leq M \leq 100 ) and P ( 0 \leq P \leq 100 ), separated by a single space. N is the number of the vertices and M is the number of the edges. P is the probability represented by a percentage. The following M lines describe the edges. Each line contains two integers v_i and u_i ( 1 \leq u_i, v_i \leq N ). ( u_i, v_i ) indicates the edge that connects the two vertices u_i and v_i . Output Output a line containing the probability with which the remained graph is connected. Your program may output an arbitrary number of digits after the decimal point. However, the absolute error should be 10^{-9} or less. Sample Input 1 3 3 50 1 2 2 3 3 1 Output for the Sample Input 1 0.500000000000 Sample Input 2 3 3 10 1 2 2 3 3 1 Output for the Sample Input 2 0.972000000000 Sample Input 3 4 5 50 1 2 2 3 3 4 4 1 1 3 Output for the Sample Input 3 0.437500000000
[ { "submission_id": "aoj_2345_10760531", "code_snippet": "/*\n * 2345.cc: Network Reliability\n */\n\n#include<cstdio>\n#include<cstdlib>\n#include<cstring>\n#include<cmath>\n#include<iostream>\n#include<string>\n#include<vector>\n#include<map>\n#include<set>\n#include<stack>\n#include<list>\n#include<queue>...
aoj_2346_cpp
Runaway Domino ``Domino effect'' is a famous play using dominoes. A player sets up a chain of dominoes stood. After a chain is formed, the player topples one end of the dominoes. The first domino topples the second domino, the second topples the third and so on. You are playing domino effect. Before you finish to set up a chain of domino, a domino block started to topple, unfortunately. You have to stop the toppling as soon as possible. The domino chain forms a polygonal line on a two-dimensional coordinate system without self intersections. The toppling starts from a certain point on the domino chain and continues toward the both end of the chain. If the toppling starts on an end of the chain, the toppling continue toward the other end. The toppling of a direction stops when you touch the toppling point or the toppling reaches an end of the domino chain. You can assume that: You are a point without volume on the two-dimensional coordinate system. The toppling stops soon after touching the toppling point. You can step over the domino chain without toppling it. You will given the form of the domino chain, the starting point of the toppling, your coordinates when the toppling started, the toppling velocity and the your velocity. You are task is to write a program that calculates your optimal move to stop the toppling at the earliest timing and calculates the minimum time to stop the toppling. Input The first line contains one integer N , which denotes the number of vertices in the polygonal line of the domino chain (2 \leq N \leq 1000) . Then N lines follow, each consists of two integers x_{i} and y_{i} , which denote the coordinates of the i -th vertex (-10,000 \leq x, y \leq 10000) . The next line consists of three integers x_{t} , y_{t} and v_{t} , which denote the coordinates of the starting point and the velocity of the toppling. The last line consists of three integers x_{p} , y_{p} and v_{p} , which denotes the coordinates of you when the toppling started and the velocity (1 \leq v_{t} \lt v_{p} \leq 10) . You may assume that the starting point of the toppling lies on the polygonal line. Output Print the minimum time to stop the toppling. The output must have a relative or absolute error less than 10^{-6} . Sample Input 1 2 0 0 15 0 5 0 1 10 10 2 Output for the Sample Input 1 5.0 Sample Input 2 3 -10 0 0 0 0 10 -1 0 1 3 0 2 Output for the Sample Input 2 4.072027 Sample Input 3 2 0 0 10 0 5 0 1 9 0 3 Output for the Sample Input 3 2.0
[ { "submission_id": "aoj_2346_1626194", "code_snippet": "#include<stdio.h>\n#include <iostream>\n#include <math.h>\n#include <numeric>\n#include <vector>\n#include <map>\n#include <functional>\n#include <stdio.h>\n#include <array>\n#include <algorithm>\n#include <string>\n#include <string.h>\n#include <asser...
aoj_2342_cpp
A Light Road There is an evil creature in a square on N-by-M grid ( 2 \leq N, M \leq 100 ), and you want to kill it using a laser generator located in a different square. Since the location and direction of the laser generator are fixed, you may need to use several mirrors to reflect laser beams. There are some obstacles on the grid and you have a limited number of mirrors. Please find out whether it is possible to kill the creature, and if possible, find the minimum number of mirrors. There are two types of single-sided mirrors; type P mirrors can be placed at the angle of 45 or 225 degrees from east-west direction, and type Q mirrors can be placed with at the angle of 135 or 315 degrees. For example, four mirrors are located properly, laser go through like the following. Note that mirrors are single-sided, and thus back side (the side with cross in the above picture) is not reflective. You have A type P mirrors, and also A type Q mirrors ( 0 \leq A \leq 10 ). Although you cannot put mirrors onto the squares with the creature or the laser generator, laser beam can pass through the square. Evil creature is killed if the laser reaches the square it is in. Input Each test case consists of several lines. The first line contains three integers, N , M , and A . Each of the following N lines contains M characters, and represents the grid information. '#', '.', 'S', 'G' indicates obstacle, empty square, the location of the laser generator, and the location of the evil creature, respectively. The first line shows the information in northernmost squares and the last line shows the information in southernmost squares. You can assume that there is exactly one laser generator and exactly one creature, and the laser generator emits laser beam always toward the south. Output Output the minimum number of mirrors used if you can kill creature, or -1 otherwise. Sample Input 1 3 3 2 S#. ... .#G Output for the Sample Input 1 2 Sample Input 2 3 3 1 S#. ... .#G Output for the Sample Input 2 -1 Sample Input 3 3 3 1 S#G ... .#. Output for the Sample Input 3 2 Sample Input 4 4 3 2 S.. ... ..# .#G Output for the Sample Input 4 -1
[ { "submission_id": "aoj_2342_10895982", "code_snippet": "/*###############################################################################################################\n## Author : Minseong Gwak (astilate, minsung05) ##\n#####################...
aoj_2352_cpp
問題文 正整数列 $X_1,X_2,...,X_N$ がある。数列 $\{1,2,...,N\}$ から部分列 $S$ を選ぶ。ただし $S$ は以下の条件を満たす必要がある。 $T=\{X_s | s \in S\}$ とする。このとき、任意の $x \in T$ について、$x$ の約数(ただし $x$ は除く)は $T$ に含まれない。 条件を満たす $S$ のうち、最も多くの要素を含むものを求めよ。また、そのような $S$ が複数ある場合は辞書式順序で最小のものを求めよ。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $X_1$ $X_2$ $...$ $X_N$ 制約 $1 \leq N \leq 100$ $1 \leq X_i \leq 10^8$ $i \neq j$ ならば $X_i \neq X_j$ 出力 求める $S$ の各要素を1行にスペースを空けて昇順で出力せよ。 Sample Input 1 3 25 125 5 Output for the Sample Input 1 1 $T=\{X_1\}=\{25\}$ は条件を満たす。 Sample Input 2 3 6 3 2 Output for the Sample Input 2 2 3 $T=\{X_2,X_3\}=\{2,3\}$ は条件を満たす。 Sample Input 3 10 10 9 8 7 6 5 4 3 2 1 Output for the Sample Input 3 1 2 3 4 5 $T=\{X_1,X_2,X_3,X_4,X_5\}=\{6,7,8,9,10\}$ は条件を満たす。 $T=\{X_1,X_2,X_4,X_5,X_7\}=\{4,6,7,9,10\}$ も条件を満たすが、$\{1,2,4,5,7\}$は $\{1,2,3,4,5\}$ より辞書順で大きいので答とはならない。
[ { "submission_id": "aoj_2352_4272561", "code_snippet": "#include<iostream>\n#include<string>\n#include<iomanip>\n#include<cmath>\n#include<vector>\n#include<algorithm>\n#include<utility>\n\nusing namespace std;\n\n#define int long long\n#define endl \"\\n\"\n\nconstexpr long long INF = (long long)1e18;\ncon...
aoj_2347_cpp
Sunny Graph The Sun is a great heavenly body. The Sun is worshiped by various religions. Bob loves the Sun and loves any object that is similar to the Sun. He noticed that he can find the shape of the Sun in certain graphs. He calls such graphs "Sunny". We define the property "Sunny" mathematically. A graph G=(V,E) with a vertex v \in V is called "Sunny" when there exists a subgraph G'=(V,E'), E' \subseteq E that has the following two properties. (Be careful, the set of vertices must be the same.) 1. The connected component containing v is a cycle that consists of three or more vertices. 2. Every other component has exactly two vertices. The following picture is an example of a subgraph G'=(V,E') that has the above property. Given a simple graph (In each edge, two end points are different. Every pair of vertices has one or no edge.) G=(V,E) , write a program that decides whether the given graph with the vertex 1 is "Sunny" or not. Input The first line contains two integers N (odd, 1 \leq N \leq 200 ) and M ( 0 \leq M \leq 20,000 ), separated by a single space. N is the number of the vertices and M is the number of the edges. The following M lines describe the edges. Each line contains two integers v_i and u_i ( 1 \leq u_i, v_i \leq N ). ( u_i, v_i ) indicates the edge that connects the two vertices u_i and v_i . u_i and v_i are different, and every pair (u_i,v_i) are different. Output Print a line containing "Yes" when the graph is "Sunny". Otherwise, print "No". Sample Input 1 5 5 1 2 2 3 3 4 4 5 1 3 Output for the Sample Input 1 Yes Sample Input 2 5 5 1 2 2 3 3 4 4 5 1 4 Output for the Sample Input 2 No
[ { "submission_id": "aoj_2347_10848164", "code_snippet": "#include <stdio.h>\n#include <string.h>\n#include <algorithm>\n#include <iostream>\n#include <math.h>\n#include <assert.h>\n#include <vector>\n#include <queue>\n#include <string>\n#include <map>\n#include <set>\n\nusing namespace std;\ntypedef long lo...
aoj_2344_cpp
Multi-ending Story You are a programmer who loves bishojo games (a sub-genre of dating simulation games). A game, which is titled "I * C * P * C!" and was released yesterday, has arrived to you just now. This game has multiple endings. When you complete all of those endings, you can get a special figure of the main heroine, Sakuya. So, you want to hurry and play the game! But, let's calm down a bit and think how to complete all of the endings in the shortest time first. In fact, you have a special skill that allows you to know the structure of branching points of games. By using the skill, you have found out that all of the branching points in this game are to select two choices "Yes" or "No", and once a different choice is taken the branched stories flow to different endings; they won't converge any more, like a binary tree. You also noticed that it takes exactly one minute to proceed the game from a branching point to another branching point or to an ending. In addition, you can assume it only takes negligible time to return to the beginning of the game (``reset'') and to play from the beginning to the first branching point. The game has an additional feature called "Quick Save", which can significantly reduce the playing time for completion. The feature allows you to record the point where you are currently playing and return there at any time later. You can record any number of times, but you can hold only the last recorded point. That is, when you use Quick Save, you overwrite the previous record. If you want to return to the overwritten point, you must play the game from the beginning once again. Well, let's estimate how long it will take for completing all of the endings in the shortest time. Input A data set is given in the following format. The first line of the data set contains one integer N ( 2 \leq N \leq 500{,}000 ), which denotes the number of the endings in this game. The following N-1 lines describe the branching points. The i -th line describes the branching point of ID number i and contains two integers Yes_i and No_i ( i + 1 \leq Yes_i, No_i \leq N ), which denote the ID numbers of the next branching points when you select Yes or No respectively. Yes_i = N means that you can reach an ending if you select Yes, and so for No_i = N . The branching point with ID 1 is the first branching point. The branching points with ID between 2 and N-1 (inclusive) appear exactly once in Yes_i 's and No_i 's. Output Print the shortest time in a line. Sample Input 1 4 2 3 4 4 4 4 Output for the Sample Input 1 6 Sample Input 2 5 5 2 3 5 5 4 5 5 Output for the Sample Input 2 8
[ { "submission_id": "aoj_2344_10854001", "code_snippet": "//made by kuailezhish\n//gl && hf\n#include <vector>\n#include <map>\n#include <set>\n#include <queue>\n#include <algorithm>\n#include <utility>\n#include <iostream>\n#include <cstdio>\n#include <cmath>\n#include <cstdlib>\n#include <string>\n#include...
aoj_2354_cpp
問題文 実数変数 $x_1, x_2, ..., x_N$ は以下の条件を満たす。 $0 \leq x_i \leq 1$ ($1 \leq i \leq N$) $w_1x_1+w_2x_2+...+w_Nx_N \leq W$ このとき $v_1x_1+v_2x_2+...+v_Nx_N$ のとりうる最大値を求めよ。そのような最大値は実際に存在することが知られている。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $W$ $w_1$ $v_1$ $w_2$ $v_2$ $...$ $w_N$ $v_N$ 制約 $1 \leq N \leq 10^5$ $1 \leq W \leq 10^5$ $-10^4 \leq w_i \leq 10^4$ $-10^4 \leq v_i \leq 10^4$ 出力 $v_1x_1+v_2x_2+...+v_Nx_N$ のとりうる最大値を1行に出力せよ。 出力には $10^{-3}$ を超える誤差があってはならない。 Sample Input 1 1 1 3 1 Output for the Sample Input 1 0.333333 $x_1=1/3$ のとき最大となる。 Sample Input 2 2 3 3 3 1 2 Output for the Sample Input 2 4.000000 Sample Input 3 2 1 -1 -3 3 10 Output for the Sample Input 3 3.666667
[ { "submission_id": "aoj_2354_2659387", "code_snippet": "#include \"bits/stdc++.h\"\n#include<unordered_map>\n#include<unordered_set>\n#include<random>\n#pragma warning(disable:4996)\nusing namespace std;\nusing ld= long double;\n\nint main()\n{\n\tint N;\n\tld W;\n\tcin>>N>>W;\n\tvector<pair<ld,ld>>pluss;\n...
aoj_2351_cpp
問題文 $N$ 本の線分 $s_1, s_2, ..., s_N$ が与えられる。このとき、 dist$(s_i, s_j)$, ( $1 \leq i,j \leq N, i \ne j $ ) のとりうる最小値を求めよ。 dist$(s_i, s_j)$ は $\sqrt{(x_i-x_j)^2 + (y_i-y_j)^2}$, ( $(x_i,y_i)$ は $s_i$ 上の点、$(x_j,y_j)$ は $s_j$ 上の点) のとりうる最小値で定義される。 以下はSample Inputのデータセットを図示したものである。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $x_{1,1}$ $y_{1,1}$ $x_{1,2}$ $y_{1,2}$ $x_{2,1}$ $y_{2,1}$ $x_{2,2}$ $y_{2,2}$ $...$ $x_{N,1}$ $y_{N,1}$ $x_{N,2}$ $y_{N,2}$ $s_i$は$(x_{i,1}, y_{i,1})$，$(x_{i,2}, y_{i,2})$を端点とする線分である。 制約 $2 \leq N \leq 10^5$ $0 \leq x_{i,j}, y_{i,j} \leq 100$ $(x_{i,1}, y_{i,1}) \neq (x_{i,2}, y_{i,2})$ 出力 最小値を1行に出力せよ。出力される値には$10^{-5}$より大きな誤差があってはならない。 Sample Input 1 4 2 0 2 25 0 30 15 20 16 20 5 15 23 0 23 30 Output for the Sample Input 1 0.41380294 Sample Input 2 6 0 0 0 5 1 3 3 5 6 0 6 10 7 4 10 4 11 1 11 3 7 0 10 0 Output for the Sample Input 2 1.00000000 Sample Input 3 6 5 5 5 45 7 45 19 45 7 30 19 30 21 34 21 44 26 45 36 28 45 45 26 5 Output for the Sample Input 3 0.83553169 Sample Input 4 11 10 10 10 90 10 90 35 90 10 60 35 60 35 60 35 90 40 10 40 90 37 45 60 45 60 10 60 45 65 10 65 90 65 90 90 90 65 60 90 65 90 60 90 90 Output for the Sample Input 4 0.00000000
[ { "submission_id": "aoj_2351_2719318", "code_snippet": "#include <iostream>\n#include <iomanip>\n#include <complex>\n#include <vector>\n#include <algorithm>\n#include <cmath>\n#include <array>\nusing namespace std;\n\nconst double EPS = 1e-10;\nconst double INF = 1e12;\n#define EQ(n,m) (abs((n)-(m)) < EPS)\...
aoj_2357_cpp
問題文 以下の条件を満たす整数列 $X_1, X_2, ..., X_N$ の個数を求めよ。 任意の整数 $i$ ($1 \leq i \leq N$)に対して、$X_j=i$ となる $j$ ($1 \leq j \leq N$)が存在する。 $X_s = t$ $X_{a_i} < X_{b_i}$ ($1 \leq i \leq C$) 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $C$ $s$ $t$ $a_1$ $b_1$ $a_2$ $b_2$ $...$ $a_C$ $b_C$ 制約 $1 \leq N \leq 2000$ $0 \leq C \leq N$ $1 \leq s \leq N$ $1 \leq t \leq N$ $1 \leq a_i \leq N$ $1 \leq b_i \leq N$ $a_i \neq b_i$ $i \neq j$ ならば $a_i \neq a_j$ 出力 条件を満たす数列の個数を $10^9+7$ で割った余りを1行に出力せよ(条件を満たす数列の個数がたかだか有限個しかないことは簡単に示される)。 Sample Input 1 3 1 1 1 1 3 Output for the Sample Input 1 2 $\{X_1, X_2, X_3\} = \{1, 2, 3\}, \{1, 3, 2\}$ の2つが条件を満たす。 Sample Input 2 4 2 1 1 2 3 3 2 Output for the Sample Input 2 0 $X_2<X_3$ かつ $X_3<X_2$ を満たす数列は存在しない。
[ { "submission_id": "aoj_2357_387243", "code_snippet": "#include <cstdio>\n#include <vector>\n#include <algorithm>\n#include <cstring>\nusing namespace std;\n\ntypedef long long int64;\n\nconst int MAX_N = 2000 + 1;\nconst int64 MOD = (int64)(1e9 + 7);\n\nint N, C, target, ord;\n\nint parent[MAX_N+1];\nvecto...
aoj_2353_cpp
問題文 有理数列 $X_0, X_1, X_2, ..., X_N$ がある。各項は以下のように定義される。 $X_0 = 0$ $X_i = X_{i-1}$ $op_i$ $Y_i$ ($1 \leq i \leq N$). ただし $op_i$ は $＋$、$−$、$×$、$÷$のいずれかである。 $X_N$ を求めよ。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $o_1$ $Y_1$ $o_2$ $Y_2$ $...$ $o_N$ $Y_N$ $o_i = 1$ のとき $op_i$ は＋、$o_i = 2$ のとき $op_i$ は−、$o_i = 3$ のとき $op_i$ は×、$o_i = 4$ のとき $op_i$ は÷である。 制約 $1 \leq N \leq 10^5$ $1 \leq o_i \leq 4$ $-10^6 \leq Y_i \leq 10^6$ $o_i=4$ ならば $Y_i \neq 0$ $X_N$ は $-2^{31}$ 以上 $2^{31}$ 未満の整数となる。 出力 $X_N$ の値を1行に出力せよ。 Sample Input 1 4 1 1 4 2 2 4 3 4 Output for the Sample Input 1 -14 $X_0 = 0$ $X_1 = X_0 ＋ 1 = 1$ $X_2 = X_1 ÷ 2 = 1/2$ $X_3 = X_2 − 4 = -7/2$ $X_4 = X_3 × 4 = -14$
[ { "submission_id": "aoj_2353_9629970", "code_snippet": "#include <iostream>\n#include <cmath>\n\nusing namespace std;\n\nsigned main() {\n ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);\n long double x = 0;\n int n; cin >> n;\n while (n--) {\n int o; long double y; cin >> o >>...
aoj_2348_cpp
Testing Circuits A Boolean expression is given. In the expression, each variable appears exactly once. Calculate the number of variable assignments that make the expression evaluate to true. Input A data set consists of only one line. The Boolean expression is given by a string which consists of digits, x, (, ), |, &, and ~. Other characters such as spaces are not contained. The expression never exceeds 1,000,000 characters. The grammar of the expressions is given by the following BNF. <expression> ::= <term> | <expression> "|" <term> <term> ::= <factor> | <term> "&" <factor> <factor> ::= <variable> | "~" <factor> | "(" <expression> ")" <variable> ::= "x" <number> <number> ::= "1" | "2" |... | "999999" | "1000000" The expression obeys this syntax and thus you do not have to care about grammatical errors. When the expression contains N variables, each variable in {x1, x2,..., xN} appears exactly once. Output Output a line containing the number of variable assignments that make the expression evaluate to true in modulo 1,000,000,007. Sample Input 1 (x1&x2) Output for the Sample Input 1 1 Sample Input 2 (x1&x2)|(x3&x4)|(~(x5|x6)&(x7&x8)) Output for the Sample Input 2 121
[ { "submission_id": "aoj_2348_10750504", "code_snippet": "#include <iostream>\n#include <cstdio>\n#include <cstdlib>\n#include <cstring>\nusing namespace std;\n#define SE second\n#define FI first\n#define MP(x,y) make_pair(x,y)\nconst int MAXN = 1000010;\nconst int MOD = 1000000007;\nchar str[MAXN];\nint sta...
aoj_2355_cpp
問題文 ふたりのプレイヤーがゲームをしている。以下、ゲームのルールを説明する。 $N×N$ マスのボードがあり、各マスには数字 $X_{i,j}$ ($1 \leq i,j \leq N$)が書かれている。先手と後手は交互に手を選んで点を積み重ねてゆく。最初に先手は $F$ 点持っており、後手は $0$ 点持っている。 $t$ ターン目($1 \leq t \leq 2N$)のプレイヤーの行動を示す。 これ以降自分と相手がどのような手を選んだとしても自分が負けてしまう場合、即座に負けを宣言してゲームを終了する。 これまでに自分が一度も選んだことのない数字を $1,2,...,N$ から一つ選んで $Y_t$ とする。 先手の手番(つまり $t$ が奇数)かつ $t>1$ のとき、先手は $X_{Y_{t}, Y_{t-1}}$ 点を得る。 $t=1$ のとき、先手の得点に変化は起きない。 後手の手番(つまり $t$ が偶数)のとき、後手は $X_{Y_{t-1}, Y_{t}}$ 点を得る。 $t=2N$ のとき、勝敗判定を行いゲームを終了する。点を多く獲得しているプレイヤーの勝ちで、点が同じ場合は引き分けとする。 ターンを終了して相手に手番を渡す。 先手と後手は以下の基準で手を選ぶ。 自分が勝ちになる手が存在するときはその手を選ぶ。自分が勝ちになる手が複数存在するときはその中からゲームが最短で終了するような手を選ぶ。 自分が勝ちになる手が存在しないとき、引き分けになる手が存在すればその手を選ぶ。 自分が負けになる手しか存在しないとき、ゲームが最長で終了するような手を選ぶ。 先手と後手がこのような基準で手を選んだとき、ゲームの結果とゲームが何ターンで終了するかを求めよ。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $N$ $F$ $X_{1,1}$ $X_{1,2}$ $...$ $X_{1,N}$ $X_{2,1}$ $X_{2,2}$ $...$ $X_{2,N}$ $...$ $X_{N,1}$ $X_{N,2}$ $...$ $X_{N,N}$ 制約 $1 \leq N \leq 8$ $-10^5 \leq F \leq 10^5$ $-10^5 \leq X_{i,j} \leq 10^5$ 出力 先手が勝つ場合は"First"、後手が勝つ場合は"Second"、引き分けになる場合は"Draw"と1行目に出力せよ。 2行目にゲームが終了するのが何ターン目になるのかを出力せよ。 Sample Input 1 2 0 1 3 1 1 Output for the Sample Input 1 Second 3 Sample Input 2 2 100 0 0 0 0 Output for the Sample Input 2 First 2 Sample Input 3 2 5 3 4 7 6 Output for the Sample Input 3 Draw 4 両者が最善を尽くした場合 $(Y_1,Y_2,Y_3,Y_4) = (1,2,2,1)$ となり、このとき両者11点を獲得して引き分けになる。
[ { "submission_id": "aoj_2355_2727715", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\n\n#define int long long\n\n#define rep(i,n) for(int i=0;i<(n);i++)\n#define pb push_back\n#define all(v) (v).begin(),(v).end()\n#define fi first\n#define se second\ntypedef vector<int>vint;\ntypedef pair<i...
aoj_2361_cpp
問題文 $1,2,...,N$ を並べ替えた順列がある。2つの異なる数字 $i$, $j$ を選んで入れ替えることを繰り返してソートされた状態( $1,2,...,N$ の順番に並んだ状態)にしたい。 数字 $i$, $j$ を入れ替える度にコストが $c_{i,j}$ 必要になる。 順列 $p$ に対して、 $p$ をソートするのに必要な最小コストを $f(p)$ とする。 $f(p)$ のとりうる最大値を求めよ。 入力 入力は以下のフォーマットに従う。与えられる数は全て整数である。 $N$ $c_{1,1}$ $c_{1,2}$ $...$ $c_{1,N}$ $c_{2,1}$ $c_{2,2}$ $...$ $c_{2,N}$ $...$ $c_{N,1}$ $c_{N,2}$ $...$ $c_{N,N}$ 制約 $2 \leq N \leq 8$ $0 \leq c_{i,j} \leq 10^5$ $c_{i,j} = c_{j,i}$ $c_{i,i} = 0$ 出力 最大値を1行に出力せよ。 Sample Input 1 3 0 1 3 1 0 8 3 8 0 Output for the Sample Input 1 5 もっとも必要コストが大きい順列は$\{1,3,2\}$で、 1,2を入れ替えて$\{2,3,1\}$とする。 1,3を入れ替えて$\{2,1,3\}$とする。 1,2を入れ替えて$\{1,2,3\}$とする。 以上の操作によりコスト5でソートでき、またこれが最善であることが証明できる。 他の順列もコスト5以下でソートできることを示すことができる。
[ { "submission_id": "aoj_2361_3596190", "code_snippet": "// #define _GLIBCXX_DEBUG // for STL debug (optional)\n#include <iostream>\n#include <iomanip>\n#include <cstdio>\n#include <string>\n#include <cstring>\n#include <deque>\n#include <list>\n#include <queue>\n#include <stack>\n#include <vector>\n#include...
aoj_2364_cpp
Lucky Dip Time Limit: 8 sec / Memory Limit: 64 MB C: 福袋 福袋，それは年始を祝う商習慣の一つである． 人気の福袋には多くの人が開店前から行列を作り，ターゲットの福袋へダッシュする． この風物詩に魅了されたあなたは，今年もお目当ての福袋を狙い，計画を立てていた． しかし，お客を呼び寄せる側の某百貨店の店長は頭を悩ませていた． どうやらフロアの準備が開店に間に合いそうにない． そこで店長はある一つのアイディアを思いついた． それは開店後，店内を徐々に開放すればなんとか営業できるのではないかというものである． あなたは刻一刻と変化する店内の情報を元に，お目当ての福袋がどの時間帯から入手できるのかを調べたい． Input 入力は単一のデータセットで与えられ，EOFで終了する． 店内の様子は各行が W 文字からなる H 行の文字列で表される． 1 行目 W H 2 < W , H <= 1000 続く H 行 店内の様子 .: 床 #: 壁 t : 目的の福袋 目的の福袋は店内に必ず1つだけ存在する． H + 2 行目 営業時間 N (0 <= N <= 1000) 続く N 行 x 1 y 1 x 2 x 2 ... x i y i ... x n y n ( x i , y i )は， i 時間目に開放される壁の座標を表す．(0 <= x i < W , 0 <= y i < H ) x i が列， y i が行である． 開放される壁の座標の位置が "#" なら "." に置き換え，"." なら何もしない． 目的の福袋が開放されることはない． (0, 0) が壁になることはない． またあるマスからの移動は，上下左右の4方向のマスへのみが可能であり，壁の上へ移動することはできないものとする． Output 左上(0, 0) から t の座標へ辿りつけるようになる時間 s (-1 <= s <= N )を1行で出力せよ． 壁を開放せずに辿りつける場合，0 を出力せよ． 営業時間が終了しても到達できなければ -1 を出力すること． Sample Input 1 10 10 .....#.... .....#.... .....#.... ######.... .......... ####...... ....###... t..#..#### ...##..... ....#...## 3 0 3 0 5 4 6 Sample Output 1 2 Sample Input 2 10 10 .....#.... .....#.... .....#.... ########## ########## ########## ########## t..#..#### ...##..... ....#...## 3 0 3 0 5 4 6 Sample Output 2 -1
[ { "submission_id": "aoj_2364_7994970", "code_snippet": "#pragma GCC optimize(\"Ofast\")\n#include <bits/stdc++.h>\nusing namespace std;\ntypedef long long int ll;\ntypedef unsigned long long int ull;\n\nmt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\nll myRand(ll B) {\n return (u...
aoj_2349_cpp
World Trip Kita_masa is planning a trip around the world. This world has N countries and the country i has M_i cities. Kita_masa wants to visit every city exactly once, and return back to the starting city. In this world, people can travel only by airplane. There are two kinds of airlines: domestic and international lines. Since international airports require special facilities such as customs and passport control, only a few cities in each country have international airports. You are given a list of all flight routes in this world and prices for each route. Now it's time to calculate the cheapest route for Kita_masa's world trip! Input The first line contains two integers N and K , which represent the number of countries and the number of flight routes, respectively. The second line contains N integers, and the i -th integer M_i represents the number of cities in the country i . The third line contains N integers too, and the i -th integer F_i represents the number of international airports in the country i . Each of the following K lines contains five integers [Country 1] [City 1] [Country 2] [City 2] [Price]. This means that, there is a bi-directional flight route between the [City 1] in [Country 1] and the [City 2] in [Country 2], and its price is [Price]. Note that cities in each country are numbered from 1, and the cities whose city number is smaller or equal to F_i have international airports. That is, if there is a flight route between the city c_1 in the country n_1 and the city c_2 in the country n_2 with n_1 \neq n_2 , it must be c_1 \leq F_{n_1} and c_2 \leq F_{n_2} . You can assume that there's no flight route which departs from one city and flies back to the same city, and that at most one flight route exists in this world for each pair of cities. The following constraints hold for each dataset: 1 \leq N \leq 15 1 \leq M_i \leq 15 1 \leq F_i \leq 4 sum(F_i) \leq 15 1 \leq Price \leq 10,000 Output Print a line that contains a single integer representing the minimum price to make a world trip. If such a trip is impossible, print -1 instead. Sample Input 1 4 6 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 3 1 2 1 1 4 1 1 2 1 3 1 1 2 1 4 1 2 3 1 4 1 1 Output for the Sample Input 1 4 Sample Input 2 2 16 4 4 2 2 1 1 1 2 1 1 1 1 3 2 1 1 1 4 1 1 2 1 3 1 1 2 1 4 2 1 3 1 4 1 2 1 2 2 1 2 1 2 3 2 2 1 2 4 1 2 2 2 3 1 2 2 2 4 2 2 3 2 4 1 1 1 2 1 1 1 1 2 2 2 1 2 2 1 2 1 2 2 2 1 Output for the Sample Input 2 8 Sample Input 3 2 2 2 1 1 1 1 1 1 2 1 1 1 2 1 1 Output for the Sample Input 3 -1
[ { "submission_id": "aoj_2349_4934973", "code_snippet": "#include<bits/stdc++.h>\ntypedef long long int ll;\ntypedef unsigned long long int ull;\n#define BIG_NUM 2000000000\n#define HUGE_NUM 1000000000000000000\n#define MOD 1000000007\n#define EPS 0.000000001\nusing namespace std;\n\n\n#define SIZE 15\n#defi...
aoj_2366_cpp
Elevator Time Limit: 8 sec / Memory Limit: 64 MB E: エレベータ あなたの友人は，キリンのマークの引越業者でアルバイトをしている． 彼の仕事は，建物から荷物を運び出すことである． 今回，彼はある n 階建てのビルからいくつかの荷物を運び出すことになった． 幸い，このビルにはエレベータが1つ備え付けられているため， エレベータで荷物を運び出すことにした． 運び出すべき荷物は，各階に複数個あり，荷物毎に重さが異なる． エレベータには，重量制限が設定されており，重さ W を超える荷物を載せることはできない． エレベータは十分に広く，重量制限を満たすならば，どれだけ多くの荷物でも載せることができる． エレベータは停止した階で荷物の搬入と搬出を行うことができる． ベテランアルバイターである彼は，エレベータに乗らずに，階段で移動する． エレベータに荷物を積み込んだ後，階段で次のエレベータの停止フロアに先回りし，荷物の搬入と搬出を行うのだ． ベテランアルバイターの彼は，荷物の搬入と搬出を非常に高速に行うことができるので，各フロアでのエレベータの停止時間は，無視することができる． よって，全ての荷物を1階に移動させるのに必要な時間は，エレベータの移動距離から容易に算出できる． 彼は，荷物をできるだけ早く1階に移動させたい． 彼はベテランアルバイターではあるが，どのような手順で各階での荷物の出し入れを行えばよいのか分からない． そこで，彼は，友人であるあなたに助けを求めてきた． あなたの仕事は，彼が全ての荷物を1階に移動させるために必要なエレベータの最小の移動距離を求めることである． Input 入力は以下の形式で与えられる． n m W 1階の荷物の情報 ... i 階の荷物の情報 ... n 階の荷物の情報 i 階の荷物の情報は，以下の形式で与えられる．(1 <= i <= n ) k i w 1 w 2 , ..., w j , ..., w k i 入力の形式の各変数の意味は次の通りである． n はフロア数(1 <= n <= 10000) m はエレベータの初期位置(1 <= m <= n) W はエレベータの重量制限(1 <= W <= 10000) k i は荷物の数(0 <= k i <= 15, 1 <= k 1 + k 2 + ... + k n <= 15) w j は荷物 j の重さ(1 <= w j <= W ) Output 最小の移動距離を1行で出力せよ． Sample Input 1 3 3 2 1 1 2 1 1 3 1 1 1 Sample Output 1 8 Sample Input 2 3 3 10 0 2 4 5 3 3 3 5 Sample Output 2 6 Sample Input 3 3 3 100 5 3 4 5 6 7 0 0 Sample Output 3 0
[ { "submission_id": "aoj_2366_9054837", "code_snippet": "#pragma GCC optimize(\"Ofast\")\n#include <bits/stdc++.h>\nusing namespace std;\ntypedef long long int ll;\ntypedef unsigned long long int ull;\n\nmt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\nll myRand(ll B) { return (ull)rn...
aoj_2359_cpp
問題文 実数変数 $X_1, X_2, ...$ があり、何らかの初期値が割り振られている。 これから $Q$ 個の情報が順番に与えられる。与えられる情報は以下の2種類のいずれかである。 min $\{X_{a_i}, X_{a_i+1}, ..., X_{b_i}\} = y_i$ である。 変数 $X_{a_i}, X_{a_i+1}, ..., X_{b_i}$ に $y_i$ を代入する。 これら $Q$ 個の情報が矛盾しないように各変数の初期値を選べるかどうか判定せよ。 入力 入力は以下の形式に従う。与えられる数は全て整数である。 $Q$ $t_1$ $a_1$ $b_1$ $y_1$ $t_2$ $a_2$ $b_2$ $y_2$ $...$ $t_Q$ $a_Q$ $b_Q$ $y_Q$ $t_i=0$ のとき、min$\{X_{a_i}, X_{a_i+1}, ..., X_{b_i}\} = y_i$ であることを示している。 $t_i=1$ のとき、$X_{a_i}, X_{a_i+1}, ..., X_{b_i}$ に $y_i$ を代入することを示している。 制約 $1 \leq Q \leq 5 \times 10^4$ $0 \leq t_i \leq 1$ $1 \leq a_i \leq b_i \leq 10^9$ $1 \leq y_i \leq 10^9$ 出力 全ての情報が矛盾しないような初期値が存在すれば"YES"を、そうでなければ"NO"を1行に出力せよ。 Sample Input 1 5 0 1 2 8 0 2 3 9 0 2 2 11 1 2 2 7 0 1 3 7 Output for the Sample Input 1 YES 初期値を、$\{X_1, X_2, X_3\} = \{8, 11, 9\}$ とする。このとき、 min$\{X_1, X_2\} = $min$\{8, 11\} = 8$ min$\{X_2, X_3\} = $min$\{11, 9\} = 9$ min$\{X_2\} = $min$\{11\} = 11$ $X_2 = 7$ min$\{X_1, X_2, X_3\} = $min$\{8, 7, 9\} = 7$ となり全ての情報と矛盾しない。 Sample Input 2 2 1 10 100 333 0 100 1000 555 Output for the Sample Input 2 NO 1つ目の情報で $X_{10}$ から $X_{100}$ の値が $333$ になったことが分かる。 2つ目の情報は min$\{X_{100},...,X_{1000}\}=555$ となることを示しているが、これは $X_{100}=333$ であることから矛盾が生じる。
[ { "submission_id": "aoj_2359_9883680", "code_snippet": "#include <iostream>\n#include <vector>\n#include <cstdio>\n#include <queue>\n#include <cstdlib>\n#include <set>\n#include <algorithm>\nusing namespace std;\n#define N (1<<18)\n\nstruct Query{\n\tint t,a,b,y;\n};\nint Q;\nQuery que[50000];\n\nset<int> n...
aoj_2369_cpp
Problem A: CatChecker 外見からねこかどうかわからない動物がいる. あなたは, 鳴き声がねこの鳴き声であればねこであり, そうでなければうさぎであると判定することにした. ねこの鳴き声は次のように定義される. "" (empty string) はねこの鳴き声である. $X$, $Y$ がねこの鳴き声であれば 'm' + $X$ + 'e' + $Y$ + 'w' は猫の鳴き声である. ただし + は文字列の連結を表す. 以上で定義されるものだけがねこの鳴き声である. BNF で表すとねこの鳴き声 $CAT$ は $CAT$ := "" (empty string) $|$ 'm' + $CAT$ + 'e' + $CAT$ + 'w' と定義される. 鳴き声を表す文字列 $S$ が与えられる. 鳴き声から動物が何であるか判定せよ. Constraints $S$ will contain between 1 and 500 characters, inclusive. Each character in $S$ will be 'm', 'e' or 'w'. Input 入力は以下の形式で与えられる: $S$ Output $S$ が猫の鳴き声であれば "Cat", そうでなければ "Rabbit" と1 行に出力せよ. Sample Input 1 mmemewwemeww Sample Output 1 Cat Sample Input 2 mewmew Sample Output 2 Rabbit
[ { "submission_id": "aoj_2369_10853968", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\nusing P = pair<int, int>;\n\nint N;\nstring S;\nmap<pair<int, int>, int> mp;\n\nbool is(int s, int t) {\n\tif (s == t) return true;\n\tif (t - s < 3 || S[s] != 'm' || S[t - 1] != 'w') return false;\n\n\t...
aoj_2373_cpp
Problem E: HullMarathon うさぎはフルマラソンという競技が好きである. この競技はチームで行う. チームメンバーは競技開始前に原点に集まる. 競技開始と同時に走り出し, 1 分後に立ち止まる．このとき，チームメンバーの位置の凸包の面積が最も大きなチームが勝ちとなる. あなたは $N$ 匹のうさぎからなるチームの監督である. $i$ 匹目のうさぎは 1 分で $r_i$ 移動することができる. このチームが最適な戦略をとった場合の, 1 分後の凸包の面積の最大値を求めよ. Constraints $N$ will be between 3 and 8, inclusive. $r_i$ will be an integer between 1 and 1,000, inclusive. Input 入力は以下の形式で与えられる: $N$ $r_1$ ... $r_N$ Output 凸包の面積の最大値を表す実数を 1 行に出力せよ. 小数点以下何桁出力してもよいが, 絶対誤差または相対誤差が $10^{-6}$ 以下のとき Accepted になる. Sample Input 1 4 5 8 58 85 Sample Output 1 2970.000000000 Sample Input 2 6 1 1 1 1 1 1 Sample Output 2 2.598076211
[ { "submission_id": "aoj_2373_10579537", "code_snippet": "#include<bits/stdc++.h>\n\nusing namespace std;\n#define rep2(i, j, k) for(ll i=ll(j);i<ll(k);i++)\n#define rep(i, j) rep2(i,0,j)\n#define rrep2(i, j, k) for(ll i=ll(j)-1;i>=ll(k);i--)\n#define rrep(i, j) rrep2(i,j,0)\n#define SZ(a) ll(a.size())\n#def...
aoj_2370_cpp
Problem B: RabbitWalking うさぎの住んでいる都市には, $V$ 個の交差点と $E$ 本の道がある. 交差点は 1-indexed で番号が付けられている. $i$ 番目の道は交差点 $a_i$ と交差点 $b_i$ を bidirectional につないでいる. うさぎは, 散歩と奇数が好きである．うさぎはある交差点から出発し, 道を奇数本辿り, 出発した頂点に戻るような経路に沿って散歩したいと思っている． この都市の市長であるねこは, 都市内の移動を効率化するために異なる2 つの交差点を結ぶ道をたくさん追加しようとしている．ただし，ある交差点の組に対して敷設することが出来る道は高々1本までである．また， ねこはいたずら好きなので，道を奇数本辿り, 出発した頂点に戻るような経路が含まれないようにしたいと思っている． 最大で何本道を付け加えられるか求めよ. ただし，最初からうさぎの要求が満たされている場合は-1 を出力せよ. Constraints $V$ will be between 1 and 100,000, inclusive. $E$ will be between 0 and 100,000, inclusive. $a_i$ and $b_i$ will be distinct. No two roads connect the same pair of intersections. Input 入力は以下の形式で与えられる: $V$ $E$ $a_1$ $b_1$ ... $a_E$ $b_E$ Output 道を追加できる本数の最大値を表す整数を 1 行に出力せよ. 最初からうさぎの要求が満たされている場合は -1 を出力せよ. Sample Input 1 8 5 1 2 6 5 6 4 1 3 4 7 Sample Output 1 11 Sample Input 2 5 8 2 1 2 4 1 3 5 4 4 1 2 3 3 5 2 5 Sample Output 2 -1
[ { "submission_id": "aoj_2370_10209831", "code_snippet": "// AOJ #2370\n// RabbitWalking 2025.2.10\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(0);\n cin.tie(0);\n \n int V, E;\n cin >> V >> E;\n\n if(E == 0) {\n ll a...
aoj_2371_cpp
Problem C: TransferTrain うなぎは電車に乗るのが好きである. いま，うなぎは駅 A から駅 B へ電車を使って行こうとしている. うなぎは急いでいるので, 最短時間の経路を選ぶことにした. ただし，うなぎは乗り換えが苦手なので, 最短時間の経路が複数ある場合は最も乗り換え回数の少ない経路を選ぶことにした. $N$ 本の路線がある. $i$ 本目の路線は $a_i$ 個の駅を通っている. $i$ 本目の路線の通る駅名は通る順に $s_{i,0}, ... , s_{i,a_i -1}$ であり, 駅間の所要時間は $t_{i,0}, ..., t_{i,a_i - 2}$ である. 電車は路線上を上下方向に走っており, 入力で与えられた逆順に乗ることもできる. 複数の路線の同じ駅名は同じ駅を表しており，乗り換えをすることが出来る. 乗り換えには駅や路線によらず $T$ 分かかる. 一本の路線が同じ駅を複数回通ることもある．もし同じ路線，同じ駅の，路線内で異なる位置の駅に移動したい場合は乗り換えをする必要がある. たとえば, C - D - E - F - D - G という路線を使って C から G まで行く場合, 始点から終点まで一本の電車で行くことも，D 駅で乗り換えて C - D, D - G と乗ることもできる. うなぎが駅 A から駅 B へ行くのにかかる時間と乗り換え回数を求めよ. 電車はとても頻繁に来るので待ち時間は無視してよい. Constraints $N$ will be between 1 and 50,000, inclusive. $T$ will be an integer between 1 and 1,000, inclusive. At least one train stops at A. At least one train stops at B. A and B will be distinct. $a_i$ will be bigger than or equal to 2. $a_1 + ... + a_N$ will be between 2 and 100,000, inclusive. $s_{i,j}$ will contain between 1 and 10 characters, inclusive. Each character in $s_{i,j}$ will be a letter ('A'-'Z', 'a'-'z'). $t_{i,j}$ will be an integer between 1 and 1,000, inclusive. Input 入力は以下の形式で与えられる: $N$ $T$ $A$ $B$ $a_1$ $s_{1,1}$ ... $s_{1,a_1}$ $t_{1,1}$ ... $t_{1,a_1 -1}$ ... $a_N$ $s_{N,1}$ ... $s_{N,a_N}$ $t_{N,1}$ ... $t_{N,a_N-1}$ Output うなぎが駅 A から駅 B へ行くのにかかる時間と乗り換え回数を空白で区切って1 行に出力せよ. Sample Input 1 2 10 Warsaw Petersburg 3 Kiev Moscow Petersburg 150 120 3 Moscow Minsk Warsaw 100 150 Sample Output 1 380 1 Sample Input 2 2 10 Warsaw Petersburg 3 Kiev Moscow Petersburg 150 120 2 Minsk Warsaw 150 Sample Output 2 -1
[ { "submission_id": "aoj_2371_10855658", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\n\nusing lint = long long;\n\nconstexpr lint LLINF = 1LL << 61;\nconstexpr pair<lint, lint> INF = make_pair(LLINF, LLINF);\n\nstruct edge{\n int to;\n lint cost;\n lint trans;\n};\n\nstruct node{\...
aoj_2367_cpp
Icy Composer Time Limit: 8 sec / Memory Limit: 64 MB F: 氷の作曲家 岡部錬太郎(愛称オカレン)は，西洋音楽の第一人者である． 彼は，5歳から作曲を行うことができた天才であり，彼が作詞・作曲した『攻城の槌』はとても有名である． 才能あふれるオカレンだが，残念なことに，彼は，レストランで食べた魚にあたって亡くなっている． ・・・少なくとも，この世界線では，そういうことになっている． 世界線とは何か？ 一つの歴史は，一つの世界線に対応する． 我々が歩んできた歴史とは，無限に存在する世界線のうちの一つに過ぎず， 別の世界線では，また違った歴史が刻まれている． オカレンは，自らを待ちうける過酷な未来に立ち向かうために，別の世界線へと旅立つことを決意したのだった． オカレンが目指す世界線は，かの有名な世界線「ヒャダインズゲート」である． 「ヒャダインズゲート」では，全ての魚は氷の魔法を用いて新鮮なまま冷凍保存されるため，魚にあたる人はいない． 世界線は，アルファベットの小文字からなる文字列で表される． 「ヒャダインズゲート」を表す文字列は既に解明されているが，非常に長い文字列で表される． これを簡潔に表記するため，文字列 seq の N 回の繰り返しを N ( seq ) と圧縮して表す． ここで， N は，1以上の自然数であり， seq は小文字からなる文字列か，圧縮して表された文字列，または，それらをいくつか連結した文字列である． 例えば，以下の表記は，文字列 bbbababababxbbbababababx を表す． 2(3(b)4(ab)x) オカレンは，彼のもつ「魔眼リーディングヒャダイナー」によって，彼がいる世界線から次に移動できる世界線を読みとることができる． 彼がいる世界線は，「ヒャダインズゲート」から遠く離れているため，直接「ヒャダインズゲート」へ移動することはできない． オカレンは，「ヒャダインズゲート」にできるだけ近づくために，「ヒャダインズゲート」に対する類似度が高い世界線へと移動することにした． 「ヒャダインズゲート」を表す文字列を x ，ある世界線を表す文字列を y とした場合， x に対する y の類似度は， y の部分文字列のうち， x にも部分文字列として現れるものの数である． ただし， y の部分文字列として同じ文字列が複数回現れたとしても，それらは，別々に数えるものとする． 類似度が同じ世界線が複数ある場合は，先に入力として与えられた世界線の方が類似度が高いとみなすものとする． 諸君には，世界線「ヒャダインズゲート」を表す文字列とオカレンが次に移動できる世界線に対応する文字列が複数与えられたときに，「ヒャダインズゲート」に対する類似度が最も高い世界線を求めてもらいたい． 健闘を祈る． エル・プサイ・コンガリィ． Input 入力は以下の形式で与えられる． n m k s t 1 t 2 ... t k 入力形式の各変数の意味は以下の通りである． n はヒャダインズゲートを表す文字列 s の長さ (1 <= n <= 250) m はオカレンが移動できる世界線を表す文字列の長さ (1 <= m <= 400) k はオカレンが移動できる世界線を表す文字列の数 (1 <= k <= 5) s はヒャダインズゲートを表す文字列 t i はオカレンが移動できる世界線を表す文字列 (1 <= i <= k ) Output 文字列 s に最も類似する文字列 t i の番号 i と類似度を空白区切りで一行で出力せよ． Sample Input 1 5 3 2 aaaaa aaa aab Sample Output 1 1 6 Sample Input 2 10 3 3 2(ab)3(bc) abc bcb cbc Sample Output 2 2 6 Sample Input 3 13 24 1 2(3(b)4(ab)x) bbbababababxbbbababababx Sample Output 3 1 300 Sample Input 4 12 7 5 hyadainsgate hyadain mahyado behoimi megante moshyas Sample Output 4 1 28 Sample Input 5 44 6 5 sh1000(1000(1000(1000(ee))))t100(a)paz100(u) sheeta pazuuu romusk apalou rlaput Sample Output 5 2 21
[ { "submission_id": "aoj_2367_372125", "code_snippet": "#include <stdio.h>\n#include <string.h>\n#include <algorithm>\n#include <iostream>\n#include <math.h>\n#include <assert.h>\n#include <vector>\n#include <queue>\n#include <string>\n#include <map>\n#include <set>\n\nusing namespace std;\ntypedef long long...
aoj_2372_cpp
Problem D: IkaNumber 数直線上の整数座標に, ねこの Taro の家, にんじん, うさぎの Hanako の家がこの順に並んでいる. 点 $x$ にいるイカは, 一回のジャンプで $x + 1$ または $x + 2$ に移動することができる. あなたは, イカが Taro の家から Hanako の家までにんじんの置かれている座標に止まらずに行く経路が何通りあるか求めようとしたが, Taro の家, にんじん, Hanako の家の座標を知らないので 求めることができなかった. そこで, 代わりに経路の数として考えられる数をすべて列挙することにした. ある Taro の家, にんじん, Hanako の家の配置に対してイカの経路数となる整数をイカ数と呼ぶことにする. $K$ 番目に小さいイカ数 (1-indexed) を mod 1,000,000,007 で求めよ. Constraints $K$ will be between 1 and 1,000,000,000,000,000,000, inclusive. Input 入力はイカの形式で与えられる: $K$ Output $K$ 番目に小さいイカ数を 1,000,000,007 で割った余りを 1 行に出力せよ. Sample Input 1 5 Sample Output 1 5 Sample Input 2 8 Sample Output 2 9
[ { "submission_id": "aoj_2372_4964447", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define REP(i, n) for (int i=0; i<(n); ++i)\n#define RREP(i, n) for (int i=(int)(n)-1; i>=0; --i)\n#define FOR(i, a, n) for (int i=(a); i<(n); ++i)\n#define RFOR(i, a, n) for (int i=(int)(n)-1; i>=(a)...
aoj_2375_cpp
Problem G: CarrotBreeding にんじんは繁殖の好きな植物である. うさぎが畑でにんじんを飼うことにした. 畑は (0, 0) と (1000000000, 1000000000) を対角線とする正方形 (boundary を含む) である. うさぎは, 2 個以上のにんじんを通るすべての直線に沿って毎日1 回ずつ水をまくことにした. このにんじんたちは, 毎日 $N$ 回ずつ水をまかれるのが繁殖に最適だと考えているので, そのような条件を満たすようにうさぎの畑に並ぶことにした. にんじんは畑内部の格子点にしか並ぶことができない. また, そのような条件を満たす並び方が複数ある場合は, 最もにんじんの個数が少ないものを選ぶことにした. 条件を満たすにんじんの配置を1 つ出力せよ. そのような配置が存在しない場合には -1 と出力せよ. Constraints $N$ will be between 1 and 1,000,000, inclusive. Input 入力は以下の形式で与えられる: $N$ Output 条件を満たす配置が存在しない場合, -1 と一行に出力せよ. 存在する場合, にんじんの本数を $K$ とすると, 以下の形式で出力せよ: $K$ $x_1$ $y_1$ ... $x_K$ $y_K$ Sample Input 1 4 Sample Output 1 4 0 0 1 0 2 0 1 1 Sample Input 2 6 Sample Output 2 4 0 0 0 1 1 0 1 1
[ { "submission_id": "aoj_2375_9450948", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\nusing ll=long long;\nusing vll=vector<ll>;\nusing vvll=vector<vll>;\n#define rep(i,n) for(ll i=0;i<ll(n);i++)\n\nll M=1e9;\n\nll num(vector<pair<ll,ll>> &V){\n ll N=V.size();\n set<tuple<ll,ll,ll>> L...
aoj_2379_cpp
Problem A: Bicube Mary Thomas has a number of sheets of squared paper. Some of squares are painted either in black or some colorful color (such as red and blue) on the front side. Cutting off the unpainted part, she will have eight opened-up unit cubes. A unit cube here refers to a cube of which each face consists of one square. She is going to build those eight unit cubes with the front side exposed and then a bicube with them. A bicube is a cube of the size 2 × 2 × 2, consisting of eight unit cubes, that satisfies the following conditions: faces of the unit cubes that comes to the inside of the bicube are all black; each face of the bicube has a uniform colorful color; and the faces of the bicube have colors all different. Your task is to write a program that reads the specification of a sheet of squared paper and decides whether a bicube can be built with the eight unit cubes resulting from it. Input The input contains the specification of a sheet. The first line contains two integers H and W , which denote the height and width of the sheet (3 ≤ H , W ≤ 50). Then H lines follow, each consisting of W characters. These lines show the squares on the front side of the sheet. A character represents the color of a grid: alphabets and digits ('A' to 'Z', 'a' to 'z', '0' to '9') for colorful squares, a hash ('#') for a black square, and a dot ('.') for an unpainted square. Each alphabet or digit denotes a unique color: squares have the same color if and only if they are represented by the same character. Each component of connected squares forms one opened-up cube. Squares are regarded as connected when they have a common edge; those just with a common vertex are not. Output Print " Yes " if a bicube can be built with the given sheet; " No " otherwise. Sample Input 1 3 40 .a....a....a....a....f....f....f....f... #bc#.#cd#.#de#.#eb#.#cb#.#dc#.#ed#.#be#. .#....#....#....#....#....#....#....#... Output for the Sample Input 1 Yes Sample Input 2 5 35 .a....a....a....a....f....f....f... #bc#.#cd#.#de#.#eb#.#cb#.#dc#.#ed#. .#..f.#....#....#....#....#....#... ..e##.............................. .b#................................ Output for the Sample Input 2 Yes Sample Input 3 3 40 .a....a....a....a....f....f....f....f... #bc#.#cd#.#de#.#eb#.#cb#.#dc#.#ed#.#eb#. .#....#....#....#....#....#....#....#... Output for the Sample Input 3 No
[ { "submission_id": "aoj_2379_3648858", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\n// 0: top, 1: front, 2:right, 3:back, 4:left, 5:bottom\nconst vector<vector<string>> dice_map = {\n {\"0...\",\n \"1234\",\n \"5...\"},\n {\"0...\",\n \"1234\",\n \".5..\"},\n {...
aoj_2376_cpp
Problem H: DisconnectedGame Taro と Hanako がゲームをしている. 最初に, 非連結な無向グラフ(二重辺や self loop を含まない) が与えられる. Taro と Hanako は交互に操作を行う. 操作では, 辺で直接つながれていない異なる2 頂点を選び, その間に辺を加える. グラフを連結にしたほうが負けである. グラフには $V$ 個の頂点がある. $V \times V$ の行列が与えられる. 行列の $(i, j)$-成分が'Y' であるとき $i$ と $j$ の間には辺があり, 'N' であるときは辺が無い. 両者が最善に操作をしたとき, どちらが勝つかを出力せよ. Constraints $V$ will be between 2 and 1,000, inclusive. $a_{i,i}$ will be 'N'. $a_{i,j}$ will be 'Y' or 'N'. $a_{i,j}$ will be equal to $a_{j,i}$. The graph will not be connected. Input 入力は以下の形式で与えられる: $V$ $a_{1,1}$ ... $a_{1,V}$ ... $a_{V,1}$ ... $a_{V,V}$ Output Taro が勝つ場合には "Taro" (quotes for clarity), Hanako が勝つ場合には "Hanako" (quotes for clarity) と 1 行に出力せよ. Sample Input 1 3 NNN NNN NNN Sample Output 1 Taro Sample Input 2 5 NNYNN NNNNN YNNNN NNNNY NNNYN Sample Output 2 Hanako Sample Input 3 8 NYNNNNNN YNNYNNYN NNNNNNNY NYNNNNYN NNNNNNNN NNNNNNNN NYNYNNNN NNYNNNNN Sample Output 3 Taro
[ { "submission_id": "aoj_2376_10238725", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\nstring dp[1009][1009][2];\nbool used[1009];\n\nvoid dfs(int pos, int &cnt, vector<vector<int>> &G) {\n used[pos] = true;\n cnt += 1;\n for (int to : G[pos]) {\n if (used[to] == true) co...
aoj_2378_cpp
Problem J: SolveMe $N$ 個の部屋があり, それぞれの部屋の床にはうさぎの絵が描かれている. あなたが部屋 $r$ のうさぎの絵の右耳の部分に乗ると, あなたは部屋 $A[r]$ に書かれたうさぎのしっぽの上にテレポートする. 同様に, 部屋 $r$ のうさぎの絵の左耳の部分に乗ると, 部屋 $B[r]$ に書かれたうさぎのしっぽの上にテレポートする. 整数 $X$, $Y$, $Z$ が与えられる. ねこは, 以下の条件を満たすようにテレポートを設定しようとしている. テレポートの $N^{2N}$ 通りの設定方法のうち, 条件を満たすものは何通りか, mod 1,000,000,007で求めよ. 条件: 任意の部屋 $r$ に対し, $r$ から右耳にちょうど $X$ 回乗り, 左耳にちょうど 1 回乗り, 右耳にちょうど $Y$ 回乗り, 左耳にちょうど 1 回乗り, 右耳にちょうど $Z$ 回乗ると, $r$ に戻る. Constraints $N$ will be between 1 and 1,000, inclusive. $X$, $Y$, $Z$ will be between 0 and 1,000,000,000,000,000,000, inclusive. Input 入力は以下の形式で与えられる: $N$ $X$ $Y$ $Z$ Output テレポートの設定方法を 1,000,000,007 で割ったあまりを表す整数を 1 行に出力せよ. Sample Input 1 3 1 0 1 Sample Output 1 18 Sample Input 2 5 8 5 8 Sample Output 2 120
[ { "submission_id": "aoj_2378_10910520", "code_snippet": "#include <iostream>\n#include <vector>\n#include <algorithm>\n#include <utility>\nusing namespace std;\n\nusing ll = long long;\n#define REP(i,n) for(ll i=0; i<ll(n); i++)\ntemplate<class T>using V = vector<T>;\n\nconst int MOD = 1000000007;\n\nstruct...
aoj_2374_cpp
Problem F: RabbitLunch うさぎは昼食ににんじんとキウイを1 個ずつ食べる. うさぎはとても個性的なので, 食べるにんじんの種類もキウイの種類も同じであるような, 異なる2 匹のうさぎが存在してはならない. にんじんは $M$ 種類ある. $i$ 種類目のにんじんは $m_i$ 個ある. キウイは $N$ 種類ある. $i$ 種類目のキウイは $n_i$ 個ある. 最大何匹のうさぎが昼食をとれるか求めよ. $m_i$ と $n_i$ は次の漸化式を用いて生成せよ. $m_0 = m0$ $m_{i+1} = (m_i * 58 + md )$ mod $(N + 1)$ $n_0 = n0$ $n_{i+1} = (n_i * 58 + nd )$ mod $(M + 1)$ Constraints $M$ will be between 1 and 2,500,000, inclusive. $N$ will be between 1 and 2,500,000, inclusive. $m0$ and $md$ will be between 0 and $N$, inclusive. $n0$ and $nd$ will be between 0 and $M$, inclusive. Input 入力は以下の形式で与えられる: $M$ $N$ $m0$ $md$ $n0$ $nd$ Output 昼食をとれるうさぎの匹数の最大値を表す整数を 1 行に出力せよ. Sample Input 1 2 3 1 3 1 0 Sample Output 1 2 Sample Input 2 5 8 1 2 3 4 Sample Output 2 19
[ { "submission_id": "aoj_2374_10850909", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\n\n#define rep(i,n) for(int i=0;i<(n);i++)\n#define REP(i,n) for(int i=1;i<=(n);i++)\n#define mp make_pair\n#define pb push_back\n#define fst first\n#define snd second\ntypedef long long ll;\ntypedef pair<...
aoj_2377_cpp
Problem I: ThreeRooks ねこがチェスの練習をしている. ねこは, $X \times Y$ のチェス盤の上にルークを 3 つ置こうとしている. このチェス盤の $K$ 個のマス目にはうさぎが座っている. $i$ 匹目のうさぎの座標は $(x[i], y[i])$ である. ただし, チェス盤の左上端のマス目の座標を $(0, 0)$, 右下端のマス目の座標を $(X-1, Y-1)$ とする。うさぎが座っている場所にはルークを置くことができない. また, 1 つのマス目に複数個のルークを置くことはできない. どの 2 つのルークも互いに攻撃し合わないようにルークを3 つ置く方法は何通りあるか, mod 1,000,000,007 で求めよ. 2 つのルークは同じ行または同じ列にあり, 間にうさぎが座っていない場合に互いに攻撃しあうものとする. Constraints $X$, $Y$ will be between 1 and 1,000,000,000, inclusive. $K$ will be between 1 and 100,000, inclusive. $x_i$ will be between 0 and $X-1$, inclusive. $y_i$ will be between 0 and $Y-1$, inclusive. No two rabbits sit on the same cell. Input 入力は以下の形式で与えられる: $X$ $Y$ $K$ $x_1$ $y_1$ ... $x_K$ $y_K$ Output ルークの配置の個数を 1,000,000,007 で割ったあまりを表す整数を 1 行に出力せよ. Sample Input 1 3 3 1 0 0 Sample Output 1 4 Sample Input 2 5 8 2 2 2 4 5 Sample Output 2 3424
[ { "submission_id": "aoj_2377_10351503", "code_snippet": "// AOJ #2377 ThreeRooks\n// 2025.4.6\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\nconst int MOD = 1000000007;\n\n#define gc() getchar_unlocked()\n#define pc(c) putchar_unlocked(c)\n\nint Cin() {\n\tint n = 0; int c = gc();...
aoj_2386_cpp
Problem H: Sightseeing Tour KM city has $N$ sightseeing areas. Currently every pair of area is connected by a bidirectional road. However for some reason, Mr. KM, the mayor of this city, decided to make all of these roads one-way . It costs $C_{i, j}$ dollars to renovate the road between area $i$ and area $j$ to a one-way road from area $i$ to area $j$. Of course, Mr. KM is economic and wants to minimize the total cost of the renovation. On the other hand, because tourism is the most important industry for KM city, there must exists a tour that goes through all the sightseeing areas, visiting each area exactly once. The first and last area of the path need not to be the same. Can you calculate the minimum total cost required for the renovation, given this situation? Input The first line contains the number of sightseeing area $N$ ($1 \leq N \leq 100$). Next $N$ lines describe the integer matrix $C$, where the $j$-th element of the $i$-th row of the input describes $C_{i,j}$ ($0 \leq C_{i,j} \leq 1,000,000$). For each $i$, you can assume $C_{i,i}$ is always zero. Output Output the minimum cost in a line. Sample Input 1 3 0 2 7 2 0 4 5 8 0 Sample Output 1 11
[ { "submission_id": "aoj_2386_1855992", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n#define int long long // <-----!!!!!!!!!!!!!!!!!!!\n\n#define rep(i,n) for (int i=0;i<(n);i++)\n#define rep2(i,a,b) for (int i=(a);i<(b);i++)\n#define rrep(i,n) for (int i=(n)-1;i>=0;i--)\n#define rrep2...
aoj_2380_cpp
Problem B: Bubble Puzzle A browser-based puzzle game called "Bubble Puzzle" is now popular on the Internet. The puzzle is played on a 4 × 4 grid, and initially there are several bubbles in the grid squares. Each bubble has a state expressed by a positive integer, and the state changes when the bubble gets stimulated. You can stimulate a bubble by clicking on it, and this will increase the bubble's state by 1. You can also click on an empty square. In this case, a bubble with state 1 is newly created in the square. When the state of a bubble becomes 5 or higher, the bubble blows up and disappears, and small waterdrops start flying in four directions (up, down, left and right). These waterdrops move one square per second. At the moment when a bubble blows up, 4 waterdrops are in the square the bubble was in, and one second later they are in the adjacent squares, and so on. A waterdrop disappears either when it hits a bubble or goes outside the grid. When a waterdrop hits a bubble, the state of the bubble gets increased by 1. Similarly, if a bubble is hit by more than one water drop at the same time, its state is increased by the number of the hitting waterdrops. Please note that waterdrops do not collide with each other. As shown in the figure above, waterdrops created by a blow-up may cause other blow-ups. In other words, one blow-up can trigger a chain reaction. You are not allowed to click on any square while waterdrops are flying (i.e., you have to wait until a chain reaction ends). The goal of this puzzle is to blow up all the bubbles and make all the squares empty as quick as possible. Your mission is to calculate the minimum number of clicks required to solve the puzzle. Input The input consists of 4 lines, each contains 4 nonnegative integers smaller than 5. Each integer describes the initial states of bubbles on grid squares. 0 indicates that the corresponding square is empty. Output Output the minimum number of clicks to blow up all the bubbles on the grid in a line. If the answer is bigger than 5, output -1 instead. No extra characters should appear in the output. Sample Input 1 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 Output for the Sample Input 1 1 Sample Input 2 2 4 4 1 2 4 4 1 2 4 4 1 2 4 4 1 Output for the Sample Input 2 5 Sample Input 3 2 4 3 4 2 2 4 4 3 3 2 2 2 3 3 3 Output for the Sample Input 3 3
[ { "submission_id": "aoj_2380_10850629", "code_snippet": "#include<bits/stdc++.h>\nusing namespace std;\n\nint ans = 6;\n\nstruct drop{\n int y, x, d;\n\n int id;\n\n bool operator==(const drop & rhs) const {\n return y == rhs.y && x == rhs.x && d == rhs.d;\n }\n};\n\ntemplate<typename T>\...
aoj_2382_cpp
Problem D: King Slime There is a grid of size W × H surrounded by walls. Some cells in the grid are occupied by slimes. The slimes want to unite with each other and become a "King Slime". In each move, a slime can move to east, west, south and north direction until it enters a cell occupied by another slime or hit the surrounding wall. If two slimes come together, they unite and become a new slime. Your task is write a program which calculates the minimum number of moves that all the slimes unite and become a King Slime. Suppose slimes move one by one and they never move simultaneously. Input The first line contains three integers N (2 ≤ N ≤ 40,000), W and H (1 ≤ W , H ≤ 100,000), which denote the number of slimes, the width and the height of the grid respectively. The following N lines describe the initial coordinates of the slimes. The i -th line contains two integers x i (1 ≤ x i ≤ W ) and y i (1 ≤ y i ≤ H ), which indicate the coordinates of the i -th slime . All the coordinates are 1-based. You may assume that each cell is occupied by at most one slime initially. Output Output the minimum number of moves that all the slimes unite and become a King Slime. Sample Input 1 4 3 3 1 1 1 3 3 1 3 3 Output for the Sample Input 1 3 Sample Input 2 2 3 3 2 2 3 3 Output for the Sample Input 2 2 Sample Input 3 2 4 4 2 2 3 3 Output for the Sample Input 3 3 Sample Input 4 2 4 4 2 2 2 3 Output for the Sample Input 4 1
[ { "submission_id": "aoj_2382_10854004", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\nconstexpr int INF = 1e9;\n\nclass union_find {\npublic:\n union_find(int N)\n : par(N, -1)\n {}\n\n int root(int x) {\n return par[x] < 0 ? x : par[x] = root(par[x]);\n }\n\n ...
aoj_2383_cpp
Problem E: Rabbit Game Playing Honestly, a rabbit does not matter. There is a rabbit playing a stage system action game. In this game, every stage has a difficulty level. The rabbit, which always needs challenges, basically wants to play more difficult stages than he has ever played. However, he sometimes needs rest too. So, to compromise, he admitted to play T or less levels easier stages than the preceding one. How many ways are there to play all the stages at once, while honoring the convention above? Maybe the answer will be a large number. So, let me know the answer modulo 1,000,000,007. Input The first line of input contains two integers N and T (1 ≤ N ≤ 100,000, 1 ≤ T ≤ 10,000). N is the number of stages, and T is the compromise level. The following N lines describe the difficulty levels of each stage. The i -th line contains one integer D i (1 ≤ D i ≤ 100,000), which is the difficulty level of the i -th stage. Output Calculate how many ways to play all the stages at once there are. Print the answer modulo 1,000,000,007 in a line. Sample Input 1 3 1 1 2 3 Output for the Sample Input 1 4 Sample Input 2 5 3 9 2 6 8 8 Output for the Sample Input 2 24 Sample Input 3 5 7 9 9 9 1 5 Output for the Sample Input 3 48
[ { "submission_id": "aoj_2383_9666591", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)\n#define rrep(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)\n#define ALL(v) (v).begin(), (v).end()\n#define UNIQUE(v) sort(ALL(v)...
aoj_2385_cpp
Problem G: Shelter Taro lives in a town with N shelters. The shape of the town is a convex polygon. He'll escape to the nearest shelter in case of emergency. Given the current location, the cost of escape is defined as the square of the distance to the nearest shelter. Because emergency occurs unpredictably, Taro can be at any point inside the town with the same probability. Calculate the expected cost of his escape. Input The first line contains two integers $M$ and $N$ ($3 \leq M \leq 100, 1 \leq N \leq 100$), which denote the number of vertices of the town and the number of shelters respectively. The following $M$ lines describe the coordinates of the vertices of the town in the conunter-clockwise order. The $i$-th line contains two integers $x_i$ and $y_i$ ($-1000 \leq x_i, y_i \leq 1000$), which indicate the coordinates of the $i$-th vertex. You may assume the polygon is always simple, that is, the edges do not touch or cross each other except for the end points. Then the following $N$ lines describe the coordinates of the shelters. The $i$-th line contains two integers $x_i$ and $y_i$, which indicate the coordinates of the $i$-th shelter. You may assume that every shelter is strictly inside the town and any two shelters do not have same coordinates. Output Output the expected cost in a line. The answer with an absolute error of less than or equal to $10^{-4}$ is considered to be correct. Sample Input 1 4 1 0 0 3 0 3 3 0 3 1 1 Sample Output 1 2.0000000000 Sample Input 2 5 2 2 0 2 2 0 2 -2 0 0 -2 0 0 1 1 Sample Output 2 1.0000000000 Sample Input 3 4 3 0 0 3 0 3 3 0 3 1 1 1 2 2 2 Sample Output 3 0.7500000000
[ { "submission_id": "aoj_2385_3684476", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\nusing ld = long double;\nusing point = std::complex<ld>;\nusing polygon = std::vector<point>;\n\nconstexpr ld eps = 1e-10;\n\nld dot(point const& a, point const& b) {\n return std::real(std::conj(a) ...
aoj_2387_cpp
Problem I: Tampopo Machine "Today is another day of endless, tedious work to put a tampopo on sashimi..." Yaruo works in a sashimi (sliced raw fish) factory. His job is to put tampopos on sashimi packages everyday. Tired of this menial job, he decided to develop a tampopo machine to do the job instead of him. The tampopo machine has the following properties. Sashimi packages are put on a conveyor belt and move from left to right. The width of a package is $W$ and the interval between two adjacent packages is $D$. The machine has $N$ magic hands placed above the conveyor belt at regular intervals of $M$. These magic hands put tampopos every $T$ seconds. In initial state, the right end of the first package is under the leftmost magic hand. The magic hands start putting a tampopo as soon as he turns on the power of the machine. The conveyor belt moves one unit length per one second. Unfortunately, after building the machine, Yaruo noticed that there exist some packages with no tampopos. Calculate the ratio of packages with no tampopos for him. When a magic hand puts a tampopo on the left or right end of a package, you can assume that the tampopo is on the package. Input The input consists of 5 integers, $W$, $D$, $N$, $M$ and $T$ which are described in the problem statement. ($1 \leq W, D, N, M, T \leq 1,000,000,000$) Output Output the ratio of packages with no tampopos in a line. The absolute error should be less than or equal to $10^{-9}$. Sample Input 1 1 1 1 1 1 Sample Output 1 0.000000000000 Sample Input 2 1 2 3 4 5 Sample Output 2 0.200000000000 Sample Input 3 3 2 2 1 6 Sample Output 3 0.166666666667
[ { "submission_id": "aoj_2387_8860926", "code_snippet": "#include <algorithm>\n#include <bitset>\n#include <cassert>\n#include <cmath>\n#include <complex>\n#include <cstdio>\n#include <cstring>\n#include <iostream>\n#include <map>\n#include <random>\n#include <unordered_map>\n#include <vector>\nusing namespa...
aoj_2390_cpp
AYBABTU There is a tree that has n nodes and n-1 edges. There are military bases on t out of the n nodes. We want to disconnect the bases as much as possible by destroying k edges. The tree will be split into k+1 regions when we destroy k edges. Given the purpose to disconnect the bases, we only consider to split in a way that each of these k+1 regions has at least one base. When we destroy an edge, we must pay destroying cost. Find the minimum destroying cost to split the tree. Input The input consists of multiple data sets. Each data set has the following format. The first line consists of three integers n , t , and k ( 1 \leq n \leq 10,000 , 1 \leq t \leq n , 0 \leq k \leq t-1 ). Each of the next n-1 lines consists of three integers representing an edge. The first two integers represent node numbers connected by the edge. A node number is a positive integer less than or equal to n . The last one integer represents destroying cost. Destroying cost is a non-negative integer less than or equal to 10,000. The next t lines contain a distinct list of integers one in each line, and represent the list of nodes with bases. The input ends with a line containing three zeros, which should not be processed. Output For each test case, print its case number and the minimum destroying cost to split the tree with the case number. Sample Input 2 2 1 1 2 1 1 2 4 3 2 1 2 1 1 3 2 1 4 3 2 3 4 0 0 0 Output for the Sample Input Case 1: 1 Case 2: 3
[ { "submission_id": "aoj_2390_10849697", "code_snippet": "/*\n * =====================================================================================\n *\n * Filename: j.cpp\n *\n * Description:\n *\n * Version: 1.0\n * Created: 2013年11月23日 14时47分56秒\n * Revision: none\n * ...
aoj_2384_cpp
Problem F: Rabbit Jumping There are $K$ rabbits playing on rocks floating in a river. They got tired of playing on the rocks on which they are standing currently, and they decided to move to other rocks. This seemed an easy task initially, but there are so many constraints that they got totally confused. First of all, by one leap, they can only move to a rock within $R$ meters from the current rock. Also, they can never leap over rocks. That is, when they leap in some direction, they should land on the nearest rock in that direction. Furthermore, since they always want to show off that they are courageous, they will never leap to rocks downriver. Finally, since they never want to admit they have been defeated, they never land on a rock if the rock is already visited by other rabbits. In this situation, is it possible for them to move to their destination rocks? If possible, please minimize the sum of their moving distance. Input The first line contains two integers $N$ ($1 \leq N \leq 100$), $K$ ($1 \leq K \leq 3$) and a real number $R$ ($0 \leq R \leq 10^4$), which denote the number of rocks, the number of rabbits, and the maximum distance a rabbit can leap, respectively. The second line contains $K$ numbers $s_1, ..., s_K$ where $s_i$ denote the rock where the $i$-th rabbit is standing. Similarly, the third line contains $K$ numbers $t_1, ..., t_K$ where $t_i$ denote the destination rock for the $i$-th rabbit. $s_1, ..., s_K$ are distinct, and $t_1, ..., t_K$ are distinct. A destination rock of a rabbit is always different from the rock he/she is standing currently. Then the following $N$ lines describe the positions of the rocks. The $i$-th line in this block contains two integers $x_i$ and $y_i$ ($0 \leq x_i, y_i \leq 10,000$), which indicate the coordinates of the $i$-th rock. The river flows along Y-axis, toward the direction where Y-coordinate decreases. No pair of rocks has identical coordinates. You may assume that the answer do not change even if you increase $R$ by up to $10^{-5}$. Output If all the rabbits can move to their destination rocks, print the minimum total distance they need to leap. If not, print "-1" (without quotes). Your answer may contain at most $10^{-6}$ of absolute error. Sample Input 6 3 1.0 1 2 3 4 5 6 0 0 1 0 2 0 0 1 1 1 2 1 Output for the Sample Input 3
[ { "submission_id": "aoj_2384_10850168", "code_snippet": "#include <iostream>\n#include <algorithm>\n#include <unordered_set>\n#include <iomanip>\n#include <vector>\n#include <bitset>\n#include <queue>\n#include <cmath>\n#include <unordered_map>\n\nusing namespace std;\n\nconst double INF = 1e100;\nint N, K;...
aoj_2393_cpp
Dungeon Creation The king demon is waiting in his dungeon to defeat a brave man. His dungeon consists of H \times W grids. Each cell is connected to four (i.e. north, south, east and west) neighboring cells and some cells are occupied by obstacles. To attack the brave man, the king demon created and sent a servant that walks around in the dungeon. However, soon the king demon found that the servant does not work as he wants. The servant is too dumb. If the dungeon had cyclic path, it might keep walking along the cycle forever. In order to make sure that the servant eventually find the brave man, the king demon decided to eliminate all cycles by building walls between cells. At the same time, he must be careful so that there is at least one path between any two cells not occupied by obstacles. Your task is to write a program that computes in how many ways the kind demon can build walls. Input The first line of each test case has two integers H and W ( 1 \leq H \leq 500 , 1 \leq W \leq 15 ), which are the height and the width of the dungeon. Following H lines consist of exactly W letters each of which is '.' (there is no obstacle on the cell) or '#' (there is an obstacle). You may assume that there is at least one cell that does not have an obstacle. The input terminates when H = 0 and W = 0 . Your program must not output for this case. Output For each test case, print its case number and the number of ways that walls can be built in one line. Since the answer can be very big, output in modulo 1,000,000,007. Sample Input 2 2 .. .. 3 3 ... ... ..# 0 0 Output for the Sample Input Case 1: 4 Case 2: 56
[ { "submission_id": "aoj_2393_10854038", "code_snippet": "#include <iostream>\n#include <algorithm>\n#include <vector>\n#include <cstdio>\n#include <cstdlib>\n#include <cstring>\n#include <climits>\n\nusing namespace std;\n\ntypedef long long LL;\nconst int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};\nconst int ...
aoj_2392_cpp
Digit For a positive integer a , let S(a) be the sum of the digits in base l . Also let L(a) be the minimum k such that S^k(a) is less than or equal to l-1 . Find the minimum a such that L(a) = N for a given N , and print a modulo m . Input The input contains several test cases, followed by a line containing "0 0 0". Each test case is given by a line with three integers N , m , l ( 0 \leq N \leq 10^5 , 1 \leq m \leq 10^9 , 2 \leq l \leq 10^9 ). Output For each test case, print its case number and the minimum a modulo m as described above. Sample Input 0 1000 10 1 1000 10 0 0 0 Output for the Sample Input Case 1: 1 Case 2: 10
[ { "submission_id": "aoj_2392_10351770", "code_snippet": "// AOJ #2392 Digit\n// 2025.4.6\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\n#define gc() getchar_unlocked()\n#define pc(c) putchar_unlocked(c)\n\nint Cin() {\n int n = 0; int c = gc();\n do n = 10*n + (c & 0xf), c...
aoj_2394_cpp
Longest Lane Mr. KM, the mayor of KM city, decided to build a new elementary school. The site for the school has an awkward polygonal shape, which caused several problems. The most serious problem was that there was not enough space for a short distance racetrack. Your task is to help Mr. KM to calculate the maximum possible length for the racetrack that can be built in the site. The track can be considered as a straight line segment whose width can be ignored. The boundary of the site has a simple polygonal shape without self-intersection, and the track can touch the boundary. Note that the boundary might not be convex. Input The input consists of multiple test cases, followed by a line containing "0". Each test case has the following format. The first line contains an integer N ( 3 \leq N \leq 100 ). Each of the following N lines contains two integers x_i and y_i ( -1,000 \leq x_i, y_i \leq 1,000 ), which describe the coordinates of a vertex of the polygonal border of the site, in counterclockwise order. Output For each test case, print its case number and the maximum possible length of the track in a line. The answer should be given as a floating point number with an absolute error of at most 10^{-6} . Sample Input 4 0 0 10 0 10 10 0 10 3 0 0 1 0 0 1 0 Output for the Sample Input Case 1: 14.142135624 Case 2: 1.41421356
[ { "submission_id": "aoj_2394_10853935", "code_snippet": "#include<cstdio>\n#include<cstring>\n#include<algorithm>\n#include<cmath>\n#include<vector>\n#include<cassert>\n#define N 110\n#define eps 1e-5\nusing namespace std;\n\nint dlcmp(double x) {return x<-eps?-1:x>eps;}\ndouble sqr(double x) {return x*x;}\...
aoj_2397_cpp
Three-way Branch There is a grid that consists of W \times H cells. The upper-left-most cell is (1, 1) . You are standing on the cell of (1,1) and you are going to move to cell of (W, H) . You can only move to adjacent lower-left, lower or lower-right cells. There are obstructions on several cells. You can not move to it. You cannot move out the grid, either. Write a program that outputs the number of ways to reach (W,H) modulo 1,000,000,009. You can assume that there is no obstruction at (1,1) . Input The first line contains three integers, the width W , the height H , and the number of obstructions N . ( 1 \leq W \leq 75 , 2 \leq H \leq 10^{18} , 0 \leq N \leq 30 ) Each of following N lines contains 2 integers, denoting the position of an obstruction (x_i, y_i) . The last test case is followed by a line containing three zeros. Output For each test case, print its case number and the number of ways to reach (W,H) modulo 1,000,000,009. Sample Input 2 4 1 2 1 2 2 1 2 2 0 0 0 Output for the Sample Input Case 1: 4 Case 2: 0
[ { "submission_id": "aoj_2397_10853997", "code_snippet": "#include <cstdio>\n#include <vector>\n#include <cstdlib>\n#include <algorithm>\n#include <cstring>\n#include <map>\n#define llint long long\n#define MOD 1000000009\n\nusing namespace std;\n\nconst int maxn = 75; //必须加 const，否则编译错误\n\nint n, N;\nllint ...
aoj_2396_cpp
Skyland Somewhere in the sky, KM kingdom built n floating islands by their highly developed technology. The islands are numbered from 1 to n . The king of the country, Kita_masa, can choose any non-negative real number as the altitude for each island, as long as the sum of the altitudes is greater than or equals to H . For floating the island i to the altitude h_i , it costs b_i h_i . Besides, it costs |h_i - h_j|c_{i,j} for each pair of islands i and j since there are communications between these islands. Recently, energy prices are rising, so the king, Kita_masa, wants to minimize the sum of the costs. The king ordered you, a court programmer, to write a program that finds the altitudes of the floating islands that minimize the cost. Input The input contains several test cases. Each test case starts with a line containing two integers n ( 1 \leq n \leq 100 ) and H ( 0\leq H \leq 1,000 ), separated by a single space. The next line contains n integers b_1 , b_2 ,..., b_n ( 0\leq b_i \leq 1,000 ). Each of the next n lines contains n integers c_{i,j} ( 0 \leq c_{i,j} \leq 1,000 ). You may assume c_{i, i} = 0 and c_{i, j} = c_{j, i} . The last test case is followed by a line containing two zeros. Output For each test case, print its case number. Then print a line containing a space-separated list of the altitudes of the islands that minimizes the sum of the costs. If there are several possible solutions, print any of them. Your answer will be accepted if the altitude of each island is non-negative, sum of the altitudes is greater than (1-10^{-9})H , and the cost calculated from your answer has an absolute or relative error less than 10^{-9} from the optimal solution. Follow the format of the sample output. Sample Input 2 1 1 3 0 1 1 0 3 3 1 2 4 0 2 0 2 0 1 0 1 0 0 0 Output for the Sample Input Case 1: 0.75 0.25 Case 2: 1.5 1.5 0.0
[ { "submission_id": "aoj_2396_1134890", "code_snippet": "#include <cstdio>\n#include <cmath>\n#include <cstring>\n#include <cstdlib>\n#include <climits>\n#include <ctime>\n#include <queue>\n#include <stack>\n#include <algorithm>\n#include <list>\n#include <vector>\n#include <set>\n#include <map>\n#include <i...
aoj_2391_cpp
Billiards Sorting Rotation is one of several popular pocket billiards games. It uses 15 balls numbered from 1 to 15, and set them up as illustrated in the following figure at the beginning of a game. (Note: the ball order is modified from real-world Rotation rules for simplicity of the problem.) [ 1] [ 2][ 3] [ 4][ 5][ 6] [ 7][ 8][ 9][10] [11][12][13][14][15] You are an engineer developing an automatic billiards machine. For the first step you had to build a machine that sets up the initial condition. This project went well, and finally made up a machine that could arrange the balls in the triangular shape. However, unfortunately, it could not place the balls in the correct order. So now you are trying to build another machine that fixes the order of balls by swapping them. To cut off the cost, it is only allowed to swap the ball #1 with its neighboring balls that are not in the same row. For example, in the case below, only the following pairs can be swapped: (1,2), (1,3), (1,8), and (1,9). [ 5] [ 2][ 3] [ 4][ 1][ 6] [ 7][ 8][ 9][10] [11][12][13][14][15] Write a program that calculates the minimum number of swaps required. Input The first line of each test case has an integer N ( 1 \leq N \leq 5 ), which is the number of the rows. The following N lines describe how the balls are arranged by the first machine; the i -th of them consists of exactly i integers, which are the ball numbers. The input terminates when N = 0. Your program must not output for this case. Output For each test case, print its case number and the minimum number of swaps. You can assume that any arrangement can be fixed by not more than 45 swaps. Sample Input 2 3 2 1 4 9 2 4 8 5 3 7 1 6 10 0 Output for the Sample Input Case 1: 1 Case 2: 13
[ { "submission_id": "aoj_2391_10851349", "code_snippet": "#include <cstdio>\n#include <iostream>\n#include <cstring>\n#include <cmath>\n#include <string>\n#include <stack>\n#include <algorithm>\n#include <queue>\n#include <map>\n#include <set>\n#include <cstdlib>\n#define INF 0x3f3f3f3f\n#define er(i) (1<<i)...
aoj_2399_cpp
Save Your Privacy! 君のプライバシーを守れ! English text is not available in this practice contest. ICPC (International Committee of Privacy and Confidence) は世界中に多くの構成員を持つ組織であり、その名の通り非常にプライバシーを尊重する、秘密主義者たちの団体である。構成員たちは必要上他の構成員の個人情報を知ってしまうことがあるが、それらを厳重に秘匿するよう義務付けられている。 しかしある日、何人かの構成員の個人情報が漏洩してしまった！ICPCの ACM (Account Control Manager: アカウント管理責任者) であるあなたは、速やかに情報を漏洩させた構成員を特定し、厳重に処分しなければならない。 あなたは構成員よりも大きな権限を持つ管理者なので、誰が誰の個人情報を知ってしまっているかを完全に把握している。もちろん、どの構成員も自分の知らない構成員の個人情報を漏洩させることはありえない。しかし、犯人は自分が知っている全ての個人情報を漏洩させたとは限らない。個人情報が漏洩してしまった構成員の一覧から、どの構成員が個人情報を漏洩させたのかを (可能ならば) 特定しよう。 ところで、ICPC という組織が何を目的として活動しているのかは最重要機密であり、管理者の権限をもってしても知ることはできない。 Input 入力ファイルは複数のデータセットを含む。1 つのデータセットは、以下の形式で与えられる。 N M 1 p 1,1 p 1,2 ... p 1,M 1 M 2 p 2,1 p 2,2 ... p 2,M 2 : M N p N,1 p N,2 ... p N,M N K l 1 l 2 ... l K N (2 ≤ N ≤ 100) は構成員の数を表す整数である。それぞれの構成員には 1 から N までの番号が振られている。 続く N 行には各構成員の番号順に、その構成員が知っている個人情報の一覧が与えられる。各行の最初の整数 M i (0 ≤ M i ≤ N)は、後に続く整数の個数を表す。残りの整数は、その構成員が個人情報を知っている構成員の番号を表す。 最後の行には、個人情報が漏洩した構成員の一覧が示される。 K (1 ≤ K ≤ N) は漏洩した構成員の人数を表し、残りの整数は漏洩した構成員の番号を表す。 入力は正しく与えられると仮定してよい。つまり、ある構成員が知っている個人情報の一覧として、同じ構成員の番号が 2 回以上与えられたり、存在しない構成員の番号が与えられることはない。漏洩した構成員の番号の一覧も同様である。 N = 0 のとき、入力は終了する。 Output 個人情報を漏洩させた構成員を特定できるならば、その構成員の番号を出力せよ。特定できない場合 -1 を出力せよ。 特定できない場合には、次の 2 つのケースがある。 1 つは、流出させた可能性がある構成員が 2 人以上挙げられる場合である。もう 1 つは、どの構成員が流出させたと仮定しても矛盾が生じる場合である。どちらの場合でも、あなたのプログラムは -1 と出力しなければならない。 Sample Input 3 2 2 3 1 1 1 1 2 2 3 3 2 2 3 1 3 1 2 1 2 5 3 1 3 4 4 1 3 4 5 2 1 3 2 1 2 0 3 1 3 5 3 2 2 1 1 1 1 2 3 3 2 1 0 Output for Sample Input 1 -1 2 -1
[ { "submission_id": "aoj_2399_10852712", "code_snippet": "#include<bits/stdc++.h>\n\n#define rep(i,n) for(int i = 0; i < n; ++i)\n#define all(x) x.begin(), x.end()\n#define X firsst\n#define Y second\n#define pb push_back\nusing namespace std;\n\nint main(void){\n int n;\n while(cin >> n && n){\n int m,...
aoj_2400_cpp
You Are the Judge 審判は君だ！ English text is not available in this practice contest. あなたはプログラミングコンテスト iCPC の審判だ。今日も何事もなく試合が終わり、後は結果を出力するだけだと思いきや、突然システムが停止してしまった！ これでは結果が出力できない！　でも、大丈夫。我々にはログがある。 あなたは優れたプログラマーであり、かつて iCPC で輝かしい成績を残したこともある。 そこであなたはシステムログから各チームの成績を割り出し、チームの順位表を出力するプログラムを作成することにした。 入力としてチームの数、問題の数、システムログが与えられる。 シムテムログは以下の 2 種類のレコードからなる。 レコード 内容 効果 tID pID time CORRECT 時刻 time に、チーム tID が 問題 pID に正解するプログラムを送信。 チーム tID の正解数に1が加算される。 チーム tID のペナルティに、(チーム tID の問題 pID に対する誤答数*1200+time)が加算される。 以後, チーム tID の問題 pID に対する解答は棄却され、システムログにも送信履歴が残らない。 tID pID time WRONG 時刻 time に、チーム tID が 問題 pID に誤答するプログラムを送信。 チーム tID の 問題 pID に対する誤答数に1が加算される。 ※上記のシステムログはこの問題のために簡略化されたものであり、本番のICPCで見られるシステムログと異なることに留意せよ iCPCにおける順位付けのルールは以下の通りである。 より多くの問題を解いたチームは順位が上になる 解いた問題が同じ場合、ペナルティの少ないチームのほうが順位が上になる 解いた問題もペナルティも同じ場合、チーム番号が小さいほうのチームが順位が上になる 入力より与えられるコンテストの情報・システムログから各チームの成績を割り出し、チームの順位表を出力せよ。 Input 入力は複数のデータセットからなる。各データセットは以下の形式で与えられる。 T P R tID 1 pID 1 time 1 message 1 tID 2 pID 2 time 2 message 2 ... tID R pID R time R message R データセットの1行目には 参加チーム数 T 、問題数 P、システムログのレコード数 R が含まれる。 続くR行にはシステムログの各レコードが含まれる。 システムログのレコードとして、チーム番号 tID i 、問題番号 pID i 、試合開始からの経過時間 time i 、メッセージの種類 message i が含まれる。 入力は以下の制約を満たす。 1 ≤ T ≤ 50 1 ≤ P ≤ 10 1 ≤ R ≤ 500 1 ≤ tID i ≤ T 1 ≤ pID i ≤ P 1 ≤ time i ≤ 10800 message i は CORRECT, WRONGのいずれか システムログのレコードは、時刻の小さいものから順に与えられ、複数のレコードの時刻が同じになることはない 入力の終わりはスペースで区切られた3個の0で与えられる。 Output 与えられたシステムログより各チームの成績・順位を割り出し、順位が上のチームから順に、チーム番号、正解数、ペナルティ を出力せよ。 Sample Input 3 3 5 3 1 800 WRONG 1 1 1200 CORRECT 3 1 1400 CORRECT 1 2 2400 CORRECT 1 3 3600 CORRECT 5 2 5 3 1 1000 WRONG 5 2 2000 CORRECT 3 1 2800 CORRECT 4 1 4000 CORRECT 5 1 5000 CORRECT 6 3 15 2 1 10 WRONG 3 3 15 WRONG 3 3 20 CORRECT 1 1 50 CORRECT 4 2 60 WRONG 1 2 70 WRONG 4 1 80 CORRECT 1 2 90 WRONG 1 2 150 CORRECT 3 1 160 WRONG 3 1 180 CORRECT 3 2 210 WRONG 5 3 500 CORRECT 4 2 720 CORRECT 5 1 1500 CORRECT 0 0 0 Output for Sample Input 1 3 7200 3 1 2600 2 0 0 5 2 7000 3 1 4000 4 1 4000 1 0 0 2 0 0 4 2 2000 5 2 2000 1 2 2600 3 2 2600 2 0 0 6 0 0
[ { "submission_id": "aoj_2400_10612926", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\nbool solve() {\n int T, P, R;\n cin >> T >> P >> R;\n if (T == 0 && P == 0 && R == 0) return false;\n vector<vector<bool>> AC(T, vector<bool>(P, false));\n vector<vector<int>> WA(T, vect...
aoj_2401_cpp
Equation 恒等式 English text is not available in this practice contest. 論理演算では，値は T と F の2種類だけを扱う． "-"を単項演算子（入力が 1 つの演算を表す記号）， "*", "+", "->" を 2 項演算子（入力が 2 つの演算を表す記号）とする． "-" は論理否定(NOT)， "*" は論理積(AND)， "+" は論理和(OR)， "->" は論理包含(IMP)を表す演算子である． これらの論理演算の真理値表を下の表に示す． x y -x (x*y) (x+y) (x->y) T T F T T T T F F F T F F T T F T T F F T F F T 論理式は以下のいずれかの形式である． X, Yは論理式とし， 2 項演算子は必ず括弧で囲むものとする． 定数: T, F 変数: a, b, c, d, e, f, g, h, i, j, k 論理否定: -X 論理積: (X*Y) 論理和: (X+Y) 論理包含: (X->Y) 2 つの論理式を等号 "=" で結合した等式が与えられる． 恒等式とは，式に現れる変数がどのような値であっても成立する等式のことである． 与えられた等式が恒等式であるかを判定するプログラムを作りたい． Input 入力は複数の行で構成され，各行は 1 つのデータセットである． データセットはT, F, a, b, c, d, e, f, g, h, i, j, k, (, ), =, -, +, *, > から成る文字列であり， 空白など他の文字を含まない． 1 行の文字数は 1000 文字以下と仮定してよい． 1 つのデータセットは等式ひとつを含む． 等式の文法は次の BNF で与えられる． すべての等式はこの構文規則に従う． <equation> ::= <formula> "=" <formula> <formula> ::= "T" | "F" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "-" <formula> | "(" <formula> "*" <formula> ")" | "(" <formula> "+" <formula> ")" | "(" <formula> "->" <formula> ")" 入力の終わりは "#" だけからなる行で示されており，この行はデータセットではない． Output 各データセットについて，等式が恒等式であれば“YES”を， そうでなければ“NO”をそれぞれ1行に出力しなさい． 出力には余分な文字を含んではならない． Sample Input -(a+b)=(-a*-b) (a->b)=(-a+b) ((a*T)+b)=(-c+(a*-b)) # Output for Sample Input YES YES NO
[ { "submission_id": "aoj_2401_10678747", "code_snippet": "#include <bits/stdc++.h>\n#include <ext/pb_ds/assoc_container.hpp>\n#include <ext/pb_ds/tree_policy.hpp>\n#include <ext/pb_ds/tag_and_trait.hpp>\nusing namespace std;\nusing namespace __gnu_pbds;\n\n\nstruct custom_hash {\n static uint64_t splitmix...
aoj_2402_cpp
Milky Way 天の川 English text is not available in this practice contest. 天の川交通公社は星間旅行ツアーの企画・運営を行う旅行会社である。 天の川交通公社では「天の川横断織姫彦星体験ツアー」という企画を計画中である。 このツアーは琴座のベガを出発し、 星々を巡って鷲座のアルタイルに向かうというものである。 あなたは天の川交通公社に社員であり、 ツアーの経路の選択を任されている。 簡単のため天の川は2次元座標上にあるものとし、 星は五芒星で表現されるものとする。 ツアーに使用する宇宙船には特殊なエンジンが搭載されており、 五芒星の線分上はエネルギー無しで移動することができる。 一方、五芒星の間を移動する際には、その距離に比例したエネルギーが必要となる。 近年、天の川交通公社の売上は低迷しており、 宇宙船のエネルギー代を始めとした各種必要経費の節約を迫られている。 あなたの仕事は、ベガからアルタイルに移動する際、 星間移動距離の総和が最小になるような経路を求め、 その総和を出力するプログラムを書くことである。 ある五芒星からその内部に含まれる別の五芒星に移動する場合、 五芒星同士が接していない場合は星間の移動として扱われることに注意せよ。 図D-1は3つ目のSample Inputを図示したものである。 図中、赤色の線分は星間移動距離の総和が最小になるような経路の、 星間移動の部分を表している。 図 D-1: 星間の移動 Input 入力は1つ以上のデータセットからなる。1つのデータセットは次の形式をしている。 N M L x 1 y 1 a 1 r 1 x 2 y 2 a 2 r 2 ... x N y N a N r N 各テストケースの初めの1行は整数N、M、Lからなり、 Nは星の数(1 ≤ N ≤ 100)、 Mはベガの番号(1 ≤ M ≤ N)、 Lはアルタイルの番号(1 ≤ L ≤ N)を表す。 続くN行には各星の情報が与えられる。 各行はx i 、y i 、a i 、r i の4つの整数からなり、 x i はi番目の星の中心のx座標(0 ≤ x i ≤ 1,000)、 y i はi番目の星の中心のy座標(0 ≤ y i ≤ 1,000)、 a i はi番目の星の中心座標と星の先端を結んだ直線がy軸となす角度(0 ≤ a i < 72)、 r i はi番目の星の中心座標から星の先端までの長さ(1 ≤ r i ≤ 1,000)である。 入力の終わりは3つのゼロを含む行で表される。 図 D-2の左の星はx=5, y=10, a=0, r=5の星を表しており、右の星はx=15, y=10, a=30, r=5の星を表している。 図 D-2: 星の例 Output 各入力ごとに、ベガからアルタイルに移動する際に必要な星間移動距離の総和の最小値を1行に出力せよ。 出力には、0.000001を超える誤差があってはならない。 Sample Input 1 1 1 5 5 0 5 2 1 2 5 5 0 5 15 5 0 5 3 2 3 15 15 0 5 5 5 10 5 25 25 20 5 0 0 0 Output for Sample Input 0.00000000000000000000 0.48943483704846357796 9.79033725601359705593
[ { "submission_id": "aoj_2402_10668015", "code_snippet": "#pragma GCC target(\"avx2\")\n#pragma GCC optimize(\"O3\")\n#pragma GCC optimize(\"unroll-loops\")\n\n// #ifndef ONLINE_JUDGE\n// #define _GLIBCXX_DEBUG // 配列外参照のエラー\n// #endif\n\n// スタンダードライブラリ\n#include <bits/stdc++.h>\nusing namespace std;\n\n// 型関...
aoj_2395_cpp
PLAY in BASIC One sunny day, Dick T. Mustang found an ancient personal computer in the closet. He brought it back to his room and turned it on with a sense of nostalgia, seeing a message coming on the screen: READY? Yes. BASIC. BASIC is a programming language designed for beginners, and was widely used from 1980's to 1990's. There have been quite a few BASIC dialects. Some of them provide the PLAY statement, which plays music when called with a string of a musical score written in Music Macro Language (MML). Dick found this statement is available on his computer and accepts the following commands in MML: Notes: Cn, C+n, C-n, Dn, D+n, D-n, En,...,... (n = 1,2,4,8,16,32,64,128 + dots) Each note command consists of a musical note followed by a duration specifier. Each musical note is one of the seven basic notes: 'C', 'D', 'E', 'F', 'G', 'A', and 'B'. It can be followed by either '+' (indicating a sharp) or '-' (a flat). The notes 'C' through 'B' form an octave as depicted in the figure below. The octave for each command is determined by the current octave, which is set by the octave commands as described later. It is not possible to play the note 'C-' of the lowest octave (1) nor the note 'B+' of the highest octave (8). Each duration specifier is basically one of the following numbers: '1', '2', '4', '8', '16', '32', '64', and '128', where '1' denotes a whole note, '2' a half note, '4' a quarter note, '8' an eighth note, and so on. This specifier is optional ; when omitted, the duration will be the default one set by the L command (which is described below). In addition, duration specifiers can contain dots next to the numbers. A dot adds the half duration of the basic note. For example, '4.' denotes the duration of '4' (a quarter) plus '8' (an eighth, i.e. half of a quarter), or as 1.5 times long as '4'. It is possible that a single note has more than one dot, where each extra dot extends the duration by half of the previous one. For example, '4..' denotes the duration of '4' plus '8' plus '16', '4...' denotes the duration of '4' plus '8' plus '16' plus '32', and so on. The duration extended by dots cannot be shorter than that of '128' due to limitation of Dick's computer; therefore neither '128.' nor '32...' will be accepted. The dots specified without the numbers extend the default duration. For example, 'C.' is equivalent to 'C4.' when the default duration is '4'. Note that 'C4C8' and 'C4.' are unequivalent ; the former contains two distinct notes, while the latter just one note. Rest: Rn (n = 1,2,4,8,16,32,64,128 + dots) The R command rests for the specified duration. The duration should be specified in the same way as the note commands, and it can be omitted, too. Note that 'R4R8' and 'R4.' are equivalent , unlike 'C4C8' and 'C4.', since the both rest for the same duration of '4' plus '8'. Octave: On (n = 1-8), <, > The O command sets the current octave to the specified number. '>' raises one octave up, and '<' drops one d ...(truncated)
[ { "submission_id": "aoj_2395_10851243", "code_snippet": "//by yjz\n#include<bits/stdc++.h>\nusing namespace std;\n#define FF first\n#define SS second\n#define PB push_back\n#define MP make_pair\n#define bged(v) (v).begin(),(v).end()\n#define foreach(it,s) for(__typeof((s).begin()) it=(s).begin();it!=(s).end...
aoj_2403_cpp
The Enemy of My Enemy is My Friend 敵の敵は味方 English text is not available in this practice contest. 時は XXXX 年。戦乱の世である。 土地や資源を巡って、隣り合った国同士の衝突がそこかしこで起こり、世の中の先行きは非常に不透明であった。そんな中とある国が、様々な国と軍事同盟を結んでこの乱世を生き延びようと考えた。軍事同盟は次の条件をみたすように行うことが出来る。 自国の隣国とは同盟を結ぶことは出来ない。 同盟をした国の隣国とは同盟を結ぶことは出来ない。 ただし、国ごとにその軍事的な強さは異なっている。軍事的に強くない複数の国と同盟を結ぶより、軍事的に非常に強い一国と同盟を結んだほうが有利であることも有り得る。ここでは、同盟に含まれる国の軍事的強さの和が最大になるような軍事同盟の結び方を考えたい。 Input 入力は複数のデータセットからなる．各データセットの形式は次の通りである。 N A 1 B 1 C 1 D 1,1 ... D 1,C 1 A 2 B 2 C 2 D 2,1 ... D 2,C 2 ... A N B N C N D N,1 ... D N,C N 各データセットでは、1行目は国の数 N (1 ≤ N ≤ 40)が与えられ、2〜N+1行目には国の詳細が与えられる。国の詳細では、国名 A i 、軍事的強さ B i 、隣接している国の数 C i 、隣接している国のリスト D i,1 ... D i,C i が与えられる。自国は1つ目の国 A 1 である。 国名 A i は全て異なり、それぞれ1文字以上16文字以下の大文字あるいは小文字アルファベットからなる。軍事的強さ B i は0以上1000以下の整数で与えられる。隣接している国のリストにある国名 D i,j は A 1 から A N のうちいずれかと一致する。また、ある国の隣接国リストにその国自身が含まれることはなく、同じ国名が2回以上重複して含まれることもない。さらに、隣接関係が対称でない場合は入力に存在しない。 入力の終了は0のみからなる行で表される。 Output 各テストケースについて、自国を含めた軍事的強さの和が最大になるような同盟を考えたとき、その強さを求め、1行で出力せよ。 Sample Input 7 INTERCAL 10 3 Chef Piet COW Chef 7 3 INTERCAL Piet COW Piet 6 2 INTERCAL Chef COW 7 2 INTERCAL Chef J 6 1 A A 12 1 J Grass 0 0 7 Qin 105 4 Zhao Wei Han Chu Zhao 81 4 Qin Wei Qi Yan Wei 70 5 Qin Zhao Han Qi Chu Han 45 3 Qin Wei Chu Qi 79 4 Zhao Wei Chu Yan Chu 102 4 Qin Wei Han Qi Yan 53 2 Zhao Qi 14 Magadha 98 8 Macedonia Kalinga Surashtra Ashmaka Kantala Andhra Gangaridai Kamapura Macedonia 79 2 Magadha Surashtra Kalinga 51 2 Magadha Andhra Surashtra 13 3 Magadha Macedonia Ashmaka Ashmaka 11 3 Magadha Surashtra Kantala Kantala 12 3 Magadha Ashmaka Andhra Andhra 14 3 Magadha Kantala Kalinga Cholas 15 3 Cheras Pandyas Anuradhapuras Cheras 8 2 Cholas Pandyas Pandyas 10 3 Cholas Cheras Anuradhapuras Anuradhapuras 7 2 Cholas Pandyas Gangaridai 20 3 Magadha Kamapura Arakan Kamapura 18 2 Magadha Gangaridai Arakan 7 1 Gangaridai 0 Output for Sample Input 22 184 120
[ { "submission_id": "aoj_2403_10848106", "code_snippet": "#include \"bits/stdc++.h\"\n#include<unordered_map>\n#include<unordered_set>\n#pragma warning(disable:4996)\nusing namespace std;\nusing ld = long double;\nconst ld eps = 1e-9;\n\n\nmap<string, int>mp;\nint num = 0;\n\nint getnum(string st) {\n\tif (m...
aoj_2404_cpp
Dog Food ドッグフード English text is not available in this practice contest. あなたは, 賢い犬を選ぶコンテストの主催者である． 種目の1つに，以下のようなものがある． この種目は，平面的な広場の上で行われる． 広場には杭がいくつか立っており，そのうちの1つと，犬はロープで結ばれている．杭やロープの太さは無視できるものとする．ロープが結ばれている杭の座標を(0，0)，犬の位置を(Dx，Dy)とする． また，ロープが結ばれている杭以外の杭の本数をｎ本とし，それらの座標を(x 1 ，y 1 )... (x n ，y n )とする． 初期状態で，ロープはピンと張られた状態である．すなわち，ロープの長さはちょうど(Dx，Dy)と(0，0)の距離に等しく，その2つの端は原点の杭と犬にそれぞれ結び付けられている． (Fx，Fy)には，ドッグフードがおかれており，この地点がゴールである．この条件下で，短い走行距離でゴールに辿りつけた犬ほど賢いと考えられる． 場合によっては，図F-1のように，直接ゴールに向かうと，別の杭にロープが引っかかり，ロープの長さが足りなくなって，ゴールにたどりつけないため，杭を迂回する必要があることに注意せよ． この例は，サンプルの1番目の入力を表している． 図 F-1: 杭を迂回する必要がある例 優秀なプログラマーでもあるあなたは，犬がゴールにたどり着けるかどうか，またたどり着けるとしたら最短距離はどうなるのかを，あらかじめ計算しておくことにした． Input 入力は1つ以上のデータセットからなる．1つのデータセットは次の形式をしている．データセット中の値は，全て整数である． n Dx Dy Fx Fx x 1 y 1 ... x n y n n はロープが繋がっていない杭の本数を表す． Dx, Dy は，犬の初期位置の座標を表す． Fx, Fy は，ゴールの位置を表す． x i , y i は，ロープが繋がっていない杭の座標を表す． データセットについて，つぎの制約が成立している． 1 ≤ n ≤ 8 -100 ≤ Dx, Dy, Fx, Fy, x i , y i ≤ 100 線分(0,0), (Dx,Dy)上に杭は存在しない. (0,0), (Dx, Dy), (Fx, Fy), (x 1 , y 1 ), (x 2 , y 2 )... (x n , y n ) はすべて異なる座標である. また，以下のことを仮定してよい. (Dx,Dy) が原点方向に対して, ε(|ε| < 0.00001)だけ変化したとき, 結果が 0.0005 より大きく変化することはない． 入力の終わりは，0を1つだけ含む行で表される． Output 各データセットについて，ゴールにたどり着ける場合は最短距離を，たどり着けない場合は-1を 1 行に出力せよ． 出力には, 0.001を超える誤差があってはならない. Sample Input 1 -4 -8 3 -8 0 -6 1 0 6 4 0 1 4 1 4 0 0 6 1 4 4 95 0 0 90 55 64 33 31 5 4 15 43 8 100 100 99 -100 60 50 6 5 12 10 24 20 30 0 70 0 -30 -10 -90 -30 0 図F-2, F-3, F-4 は，それぞれサンプルの2番目から4番目の配置を示している． 図 F-2: 2番目のサンプル 図 F-3: 3番目のサンプル 図 F-4: 4番目のサンプル Output for Sample Input 8.0776872 7.2360679 -1 140.2870005 273.9090890
[ { "submission_id": "aoj_2404_2818209", "code_snippet": "#include <iostream>\n#include <iomanip>\n#include <complex>\n#include <vector>\n#include <algorithm>\n#include <cmath>\n#include <array>\nusing namespace std;\n\nconst double EPS = 1e-10;\nconst double INF = 1e12;\nconst double PI = acos(-1);\n#define ...
aoj_2405_cpp
Sister Ports 姉妹港 English text is not available in this practice contest. ACM 国は正 n 角形の島国である． n 個の角に港があり，ある角の港から時計回りに 1 から n までの番号が順番に付いている． 港は点とみなす． ACM 国には，二種類の道路がある． 隣り合う港を繋ぐ道路 全ての隣接する港は道路で接続されている．すなわち，番号の差が 1 である港同士および港 1 と港 n の間に道路がある．この種類の道路は n 本ある． 島の内部を通る道路 一部の隣接しない港の間も，道路で接続されている．この種類の道路は m 本あり，道路 i は港 a i と港 b i を接続する． 道路は線分とみなす．ACM 国では，任意の 2 つの道路は端点以外で共有点を持たない． 図 G-1: 港と道路の例 ACM 国は，港に事故が起きた時などに備えるため，全ての港について姉妹港を決め，いつでも互いを補助できるよう準備させることにした． 全ての港について姉妹港は 1 つで，港 a が港 b の姉妹港であるとき，港 b も港 a の姉妹港である． すなわち，n 個の港から，港が重複しない n/2 個のペアを作る． このとき，ACM 国は，姉妹港の間には必ず道がなければならないとすることにした． ACM 国に住む優秀なプログラマーであるあなたの仕事は， 全港に対する姉妹港の選び方の総数を計算するプログラムを作成することである． 図 G-2: 姉妹港の選び方の例（姉妹港同士の間の道路を赤色太線で表示している） Input 入力は1つ以上のデータセットからなる．1つのデータセットは次の形式をしている． n m a 1 b 1 ... a m b m 先頭行は 2 つの正の整数 n, m からなり， それぞれ ACM 国の港の数および種類 2 の道路の数を表す． 続く m 行の i 行目は 2 個の整数 a i , b i からなり， 道路 i が港 a i , b i を結ぶことを表す． 任意の 2 つの道路は端点以外で共有点を持たない．また，これらの数は以下の範囲の値をとる． 3 ≤ n ≤ 50,000 0 ≤ m ≤ 50,000 1 ≤ a i , b i ≤ n 入力の終わりはふたつのゼロを含む行で表される． Output 各データセットについて， 姉妹港の選び方の総数を 1000003 で割った余りを出力せよ． 適切な姉妹港の選び方が存在しない場合は 0 を出力せよ． Sample Input 6 1 1 4 8 3 1 6 1 5 2 5 12 3 3 10 4 9 6 9 3 0 0 0 Output for Sample Input 3 5 7 0
[ { "submission_id": "aoj_2405_10826161", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\nusing ll=long long;\nusing ull=unsigned long long;\nusing P=pair<ll,ll>;\ntemplate<typename T>using minque=priority_queue<T,vector<T>,greater<T>>;\ntemplate<typename T>bool chmax(T &a,const T &b){return ...
aoj_2398_cpp
Tree Allocation A tree is one of the most popular data structures in computer science. Tree itself is very elegant, but it is incompatible with current computer architecture. In the current architecture, memory can be regarded as a one-dimensional array. Since a tree is not a one-dimensional structure, cache efficiency may come into question when we allocate a tree on memory. We can access the data faster if it is contained in cache. Let us consider the allocation of nodes of a tree which achieves high cache performance. We define the cost of allocation for a tree as follows. For simplicity, we regard memory to be separated to blocks each can store at most B nodes of a tree. When we access data in a block, all data in the block are stored in cache and access request to data in the block will be faster. The cost of an access to node u after node v is 0 if u and v are in same block, and 1 otherwise. Initially, cache has no data and the cost of an access to a node is always 1. The cost of the path v_1 , v_2 ,..., v_n is sum of the cost when we access the nodes v_1 , v_2 ,..., v_n in this order. For a tree, we define the cost of allocation as a maximum cost of the paths from root node to each terminal node. The figures below show examples of allocation when B = 4 and node 1 is the root node (it corresponds to the tree described in the third sample input). Each frame represents a block. The left figure is an example of allocation whose cost is 3. It is not optimal, because the right example achieves the optimal allocation cost 2. Given a tree, for each node i in the tree, calculate the minimum cost of allocation when the node i is the root node. Input The input contains several test cases. Each test case starts with a line containing two integers N ( 1 \leq N \leq 100,000 ) and B ( 1\leq B \leq N ), separated by a single space. Each of the next N-1 lines contains an integer. The i -th integer p_i ( 1 \leq p_i \leq i ) denotes that the node i+1 and the node p_i are connected. The nodes are numbered from 1 to N . The last test case is followed by a line containing two zeros. Output For each test case, print its case number. Then print N lines. The i -th line should contain an integer which denotes the minimum cost of allocation of the given tree when node i is the root node. Follow the format of the sample output. Sample Input 3 1 1 2 3 2 1 1 10 4 1 1 2 3 3 4 4 4 5 0 0 Output for the Sample Input Case 1: 3 2 3 Case 2: 2 2 2 Case 3: 2 2 2 2 2 2 2 2 2 3
[ { "submission_id": "aoj_2398_10852730", "code_snippet": "#include <cstring>\n#include <cstdio>\n#include <algorithm>\n#include <cassert>\n#include <iostream>\n#include <vector>\nusing namespace std;\nconst int Maxn = 100010;\t\nint n, b;\nvector<int> vec[Maxn];\nint dp[Maxn], B[Maxn],tmpdp[Maxn];\nbool cmp(...
aoj_2410_cpp
E - じゃんけん 問題文 E 君はじゃんけんが大好きである (ちなみにじゃんけんのルールについては Wikipediaのじゃんけんのページ を参照せよ)． ある日，町内でじゃんけん大会があるということを知った E 君は，じゃんけんの腕に自信があったこともあり早速出場することにした． ところが大会当日，E 君を待ち受けていたのは，普通の「グー・チョキ・パー」のみからなる普通のじゃんけんではなく， より多くの手からなる 一般化されたじゃんけん であった． 一般化されたじゃんけん は 2 人のプレイヤーで行われるゲームである． まず，2 人にはこのじゃんけんにおいて使用出来る手の個数 N と， N 個の手の勝敗関係を示す表が伝えられる． そして，通常のじゃんけんと同じように同時に手を出しあい，伝えられた手の勝敗関係に基いて勝敗を決める．これを 1,000 回 繰り返す． 1 回のじゃんけんの勝敗の結果によって得点が手に入り，相手に勝利した場合は 3 点，相手と「あいこ」になった場合は 1 点が手に入る．相手に負けてしまった場合は得点を得られない． このなんだかよくわからないルールのじゃんけんにすっかり戦意を喪失してしまった E 君であったが，どうやら聞くところによると，最終的に相手に得点で勝てなくても， 350 点 以上を獲得すれば何か景品がもらえるらしい． めんどくさいので 350 点 を得てさっさと大会を後にすることにした． この問題の目的は，一般化されたじゃんけんをプレイする AI を作成し，ジャッジ側の用意した AI と対戦させて 350 点 以上を獲得することである． 入出力形式 まず入力が以下の形式で与えられる． N a 1,1 ... a 1,N ... a N,1 ... a N,N N はじゃんけんの手の数である． 各 a i,j は N 個の手の勝敗関係を表す． a i,j は - ， o ， x のいずれかであり， - ならば手 i が手 j に対し引き分けることを， o ならば手 i が手 j に対し勝つことを， x なら負けることを示す． この条件の下で 1,000回 AI とじゃんけんをする． プログラムは自分の使う手を出力すると，ジャッジの AI が使った手を入力で受けとる事ができる． 例えば C/C++で 3 番目の手を使う場合は printf("3\n"); fflush(stdout); とする．次に， scanf("%d", &judge_ai_hand); とすると変数 judge_ai_hand にジャッジの AI が使った手が入る． なおじゃんけんの手は1-indexedである． 1,000 回のじゃんけんを終えた後は直ちにプログラムを終了せよ．その後，獲得できた得点の合計が 350 点以上であれば正答と判定される． 制約 3 ≤ N ≤ 10 i ≠ j のとき， a i,j ∈ { o , x } であり， a i,j = o ， a j,i = x または a i,j = x ， a j,i = o のどちらか片方が成り立つ． i = j のとき， a i,j = - である． AI の出す手は勝敗関係の表 a i,j と AI の過去の手にだけ依存し，競技者のプログラムの過去の手や直前に出した手には依存しない． N は整数である． データセットに N=10 のテストケースは高々 6 個しか含まれていない． 入出力例1 じゃんけんの説明 プログラムの出力 プログラムへの入力 4 -oox x-oo xx-o oxx- 1 回目に競技者の AI が使った手 1 1 回目にジャッジの AI が使った手 2 ... ... ... 1,000 回目に競技者の AI が使った手 4 1,000 回目にジャッジの AI が使った手 3 最初にプログラムはじゃんけんの手の表を受け取る．その後，1,000 回のじゃんけんを行う． ここで，1 回目のじゃんけんでは競技者の AI はジャッジの AI に勝利しているが， 1,000 回目のじゃんけんでは競技者の AI はジャッジの AI に敗北していることに注意せよ． Writer: 楠本充，小浜翔太郎 Tester: 森槙悟
[ { "submission_id": "aoj_2410_5021796", "code_snippet": "#include <bits/stdc++.h>\n#define rep(i, n) for (int i = 0; i < (n); ++i)\n#define FOR(i, m, n) for (int i = (m); i < (n); ++i)\n#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)\n#define rfor(i, m, n) for (int i = (m); i >= (n); --i)\n#define unless...
aoj_2412_cpp
G - 村 問題文 きつねのしえるは，休暇でとある小さな村を訪れている．彼女が驚いたのは，その村の表札がもつ性質である． 村には N 個の家屋がある．ここでは簡単のため，村は 2 次元平面であるとし，家屋はこの平面上の点であると見なす． それぞれの家屋には表札が 1 個設けられており，その家の苗字を表していた．しえるは村の中を訪問するにつれて，この村の表札が次のような性質を持っていることに気付いた． ある実数 R が存在する． もし 2 つの家屋の距離が R 以下であるなら，その 2 つの家屋は同じ表札を持つ． もし 2 つの家屋の距離が 3R 以上であるなら，その 2 つの家屋は異なる表札を持つ． 任意の 2 つの家屋の距離は R 以下であるか 3R 以上であるかのどちらかである． ここで，家屋同士の距離は，平面上のユークリッド距離によって計測するものとする． しえるはこの村に表札が全部で何種類あるのかが気になったが，この村は意外に広いということに気付いたので，計算機を使ってこの答えを模索することにした． 入力形式 入力は以下の形式で与えられる． N R x 1 y 1 x 2 y 2 ... x N y N N は家屋の個数である． R は家屋の配置の制約に関する値である． (x i , y i ) は家屋 i の座標を表す． 出力形式 村に存在する表札の種類の数を求めよ． 制約 1 ≤ N ≤ 2 × 10 5 1 ≤ R ≤ 10 3 |x i |, |y i | ≤ 10 6 N は整数である． R, x i , y i は実数で，小数第 3 位まで表される． 任意の 1 ≤ i < j ≤ N に対して d ij = √{(x i - x j ) 2 + (y i - y j ) 2 } とおくとき， d ij ≤ R か 3R ≤ d ij のどちらかが満たされる． この問題の判定には，15 点分のテストケースのグループが設定されている． このグループに含まれるテストケースは上記の制約に加えて下記の制約も満たす． 答えは 10 以下である． 入出力例 入力例 1 5 3.000 1.000 0.000 0.000 0.000 -1.000 0.000 10.000 0.000 -10.000 0.000 出力例 1 3 家屋 1,2,3 と家屋 4 と家屋 5 で表札が異なる．全体で 3 つの表札が存在する． 入力例 2 12 1.234 0.500 0.000 -0.500 0.000 0.000 0.000 0.000 -0.500 55.500 55.000 -55.500 55.000 55.000 55.000 55.000 -55.500 99.500 99.000 -99.500 99.000 99.000 99.000 99.000 -99.500 出力例 2 7 入力例 3 5 99.999 0.000 0.000 49.999 0.001 0.000 0.000 -49.999 -0.001 0.000 0.000 出力例 3 1 Writer: 楠本充 Tester: 小浜翔太郎
[ { "submission_id": "aoj_2412_10916185", "code_snippet": "#include <iostream>\n#include <vector>\n#include <string>\n#include <unordered_map>\n#include <utility>\n#include <cstdint>\nusing namespace std;\n\nstruct DSU {\n vector<int> p, sz;\n DSU(int n) : p(n), sz(n, 1) { for (int i = 0; i < n; ++i) p[...
aoj_2411_cpp
F - Acceleration of Network インターネットと言う広大な海は少しずつ黒く塗りつぶされていった。 ボットの反乱、DDOS攻撃の嵐、ウィルスの蔓延、 何度も何度も繰り返されたクラッカーとの戦争で、人もインターネットもボロボロになった。 人の手では、インターネットはどうにもならない。 だから人は、とんでもない時間をかけて インターネットを復旧できる「少女」を造った。 少女は、インターネットの手当をはじめた。 果てしなく広いインターネットの世界をどうにかしようと頑張った。 まだ少女ひとりでは撚り対線を織る事くらいしかできないけど、 長い長い時がすぎてインターネットが少し復旧すれば、 みんなと一緒に頑張れるだろうという期待をこめて。 問題文 少女はかつてインターネットに存在した N 個のサービスを復旧するために日々頑張っている． 現在を 0 日目とする． インターネットがどの程度復旧しているかを 復旧度 という指標で表し，現在の復旧度は 0 であるとする． 少女は毎日作業をし，復旧度を 1 日につき 1 ずつ上げていく． 任意のまだ復旧していないサービス i は，復旧度が w i 以上になると自動的に復旧する． サービス i が復旧すると，みんなが手伝ってくれることにより，復旧した次の日から x i 日間だけ作業がはかどり，復旧度の増加が加速する． サービスには 3 つの種類があり，種類によって復旧度がどの程度増加するのかが異なる． サービスの種類を 0, 1, 2 の番号で表すとする． サービス i の種類を t i (∈ {0, 1, 2}) とすると， サービス i が復旧してから d-1 日目から d 日目にかけて (1 ≤ d ≤ x i ) ， t i =0 の場合は 1 ， t i =1 の場合は d ， そして t i =2 の場合は d 2 だけ，少女の作業とは別に復旧度が増加する． また，同時に複数のサービスが復旧している場合，それぞれのサービスは独立に並行して復旧度を増加させる． 少女はサービスが復旧するまでにとんでもない時間がかかると思ったので，現在から何日目にサービスが復旧するか調べることにした． またある日にち y j に復旧度がいくらになっているかも気になったので，それも Q 日分だけ調べることにした． 入力形式 入力は以下の形式で与えられる． N Q w 1 t 1 x 1 ... w N t N x N y 1 ... y Q 出力形式 最初に N 行出力し， i 行目にはサービス i の復旧する日にちを出力せよ．次に Q 行出力し， j 行目には y j 日目に復旧度がいくらになっているかを出力せよ． サービスが復旧する日にちが 3,652,425 を超える場合は Many years later と出力せよ． 制約 0 ≤ N ≤ 10 5 1 ≤ Q ≤ 10 5 0 ≤ w i < 2 60 w i ≤ w i+1 (1 ≤ i < N) t i ∈ {0, 1, 2} 1 ≤ x i ≤ 10 4 0 ≤ y j ≤ 3,652,425 y j < y j+1 (1 ≤ j < Q) 入力値はすべて整数である． この問題の判定には，15 点分のテストケースのグループが設定されている．このグループに含まれるテストケースは上記の制約に加えて下記の制約も満たす． N,Q,w i ,y j ≤ 1,000 注意 0 日目の復旧度は 0 である． w i =0 の時，サービス i は 0 日目に復旧する． 入出力例 入力例1 3 11 1 0 2 4 1 3 7 2 4 0 1 2 3 4 5 6 7 8 9 10 出力例1 1 3 4 0 1 3 5 7 11 19 29 46 47 48 入力例2 5 5 10000 0 20 10000 1 30 10000 0 40 10000 2 70 30000 2 10000 5000 10000 15000 20000 25000 出力例2 10000 10000 10000 10000 10039 5000 10000 40711690801 329498273301 333383477320 入力例3 2 2 3652425 0 1 3652426 2 10000 3652424 3652425 出力例3 3652425 Many years later 3652424 3652425 2つ目のサービスは復旧する日にちが 3,652,425 日を超えているので Many years later と出力している． Writer : 森槙悟 Tester : 田村和範
[ { "submission_id": "aoj_2411_10307782", "code_snippet": "// AOJ #2411 Acceleration of Network\n// 2025.3.17\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\n#define gc() getchar_unlocked()\n#define pc(c) putchar_unlocked(c)\n\nint Cin() { // 整数の入力\n\tint n = 0; int c = gc();\n\td...
aoj_2415_cpp
J - 刺身 問題文 きつねのしえるは川で釣りをしていた．黒くて細長い魚を手に入れることができたので，その場で切り刻んで刺身にして食べることにした． 魚は体長が N センチメートルある．奇妙なことに，この魚は身体の部分ごとに密度が異なっていた． 魚の身体を頭から 1 センチメートルごとに区切って番号を 1, 2, ..., N と付けるとき，身体の i 番目の部分の重みは w_i であった． 魚の i 番目から j 番目までの部分を [i..j] と表すことにする． 最初，しえるは魚の身体 [0..N-1] を 1 枚だけ持っていると見なせる．しえるはこれを切っていき最終的に N 個に分割された魚の身体 [0..0], [1..1], ..., [N-1..N-1] を得たい． しえるは今野外におり，まな板などを持っていないので，次のようなアクロバティックな方法で魚の身体を切っていくことにした ： まず，魚の身体を 1 枚取る．これを [i..j] とする．この魚の身体は長さが少なくとも 2 センチメートル以上でなければならない．すなわち， j-i ≥ 1 でなければならない．次に，それを空中に投げる．そして日本刀を手に持ち，宙に舞う魚を真っ二つに切る．このとき，しえるは強靭な運動神経によって任意の位置でこの魚を切ることができるが，必ず 1 センチメートル区切りの位置で切るものとする．これにより，元の魚の身体 [i..j] を，任意の切断位置 k (i ≤ k < j) によって， [i..k] と [k+1..j] の 2 つに分割するのである． このアクロバティックな方法で魚の身体を 2 つに切るとき，元の身体の重さ (= w i +w i+1 +...+w j ) だけコストがかかる． しえるは，魚のすべての部分を 1 センチメートル区切りに切るのにかかるコストの合計値を最小にしたい． 入力形式 入力は以下の形式で与えられる． N w 1 w 2 ... w N N は魚の体長である． w i は魚の i 番目の部分の重さである． 出力形式 魚を N 個に切り分けるのにかかるコストの合計の最小値を出力せよ． 制約 2 ≤ N ≤ 4,000 1 ≤ w i ≤ 10 10 入力値はすべて整数である． この問題の判定には，3 点分のテストケースのグループが設定されている． このグループに含まれるテストケースは上記の制約に加えて下記の制約も満たす． 1 ≤ N ≤ 100 入出力例 入力例 1 3 1 2 3 出力例 1 9 まず，魚全体を 2 番目と 3 番目の部分の間で切る．これには 1+2+3 = 6 のコストがかかる． 次に，1 番目と 2 番目の部分の間で切る．これには 1+2=3 のコストがかかる．合計で 6+3=9 のコストがかかり，これが最善手である． 入力例 2 6 9876543210 9876543210 9876543210 9876543210 9876543210 9876543210 出力例 2 158024691360 入力例 3 10 127 131 137 139 149 151 157 163 167 173 出力例 3 5016 Writer: 楠本充 Tester: 花田裕一朗
[ { "submission_id": "aoj_2415_11008227", "code_snippet": "#define _CRT_SECURE_NO_WARNINGS\n#include <cstdio>\n#include <iostream>\n#include <stack>\n#include <queue>\n#include <algorithm>\n#include <functional>\n#include <set>\n#include <map>\n#include <string>\n#include <vector>\n#include <cmath>\n#include<...
aoj_2413_cpp
H - 植林 問題文 とある大学の魔法学部の生徒であるK君は広大な屋敷に住んでいる． 屋敷の裏には林が広がっていたが，所々木が生えていない箇所があった． このままでは屋敷からの見た目が悪いと感じたので，K君は木が生えていない箇所に木を植えることに決めた． 魔法使いの卵であるK君は使い魔を召喚することが出来るので，植林の作業を使い魔にやらせようと考えた． 林は H × W 個のセルを持つ長方形領域とみなすことが出来る． 各セルは木が1本生えているか1本も生えていないかのどちらかである． K君はこの H × W 個のセルのどれか 1 つを指定し，そこに使い魔を召喚する． しかしK君はまだ未熟者なので，魔力を調節することが出来ず，使い魔を召喚するときは必ず 5 匹召喚してしまう． さらに悪いことに，K君が召喚する使い魔はひねくれもので，訪れたセルに木が生えていない場合はそこに木を植えるが，訪れたセルに既に木が生えている場合はそのセルの木を消してしまう． 召喚された使い魔のうちの 4 匹は，指定されたセルを始点として東西南北に散らばり1直線上を進み，1つ1つセルを訪れていく．これらの使い魔は林の外に出ると消える． 残りの使い魔は指定されたセルのみを訪問し，その後直ちに消える． より正確に言えば，K君がセル (i, j) に使い魔を召喚すると， i 行目か或いは j 列目にある H+W-1 個のセルに対し， 木が生えていなければ木が植えられ，木が生えていれば木が消されるという操作が行われる． 召喚には多くの魔力を必要とするので，出来るだけ少ない召喚回数で林を木で覆いつくしたい． K君はどのセルに使い魔を召喚すれば最小の召喚回数で林を木で覆いつくすことが出来るだろうか． 入力形式 入力は以下の形式で与えられる． H W a 1,1 ... a 1,W ... a H,1 ... a H,W a i,j が 1 ならセル (i,j) に木が生えていることを意味し, 0 なら生えていないことを意味する． 出力形式 もし林を木で覆いつくすことが不可能なら，1行に Impossible を出力せよ． そうでなければ，召喚回数を最小にするような召喚手順を以下の形式で H 行に出力せよ． b 1,1 ... b 1,W ... b H,1 ... b H,W b i,j は 0 もしくは 1 でなければならず, 1 ならセル (i,j) に使い魔を召喚する事を意味し， 0 なら召喚しない事を意味する． 2回同じ場所に使い魔を召喚しても意味が無いことに注意せよ．召喚回数を最小にするような召喚手順が複数ある場合はどれを出力しても良い． 制約 2 ≤ H，W ≤ 1000 H，W は偶数 a i,j ∈ {0, 1} この問題の判定には，3 点分のテストケースのグループが設定されている． このグループに含まれるテストケースは上記の制約に加えて下記の制約も満たす． H × W ≤ 20 入出力例 入力例 1 4 4 0 0 0 1 0 1 1 0 0 1 1 0 1 0 0 0 出力例 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 セル (1,1) とセル (4,4) に使い魔を召喚することで林を木で覆いつくすことが出来る． Writer: 田村和範 Tester: 花田裕一朗
[ { "submission_id": "aoj_2413_10283335", "code_snippet": "#include \"bits/stdc++.h\"\nusing namespace std;\nusing ll = long long;\nusing ld = long double;\nusing ull = unsigned long long;\n#define rep(i, m, n) for (ll i = (ll)m; i < (ll)n; i++)\n#define drep(i, m, n) for (ll i = m - 1; i >= n; i--)\n#define ...
aoj_2419_cpp
Acrophobia C: 高所恐怖症 高杉やよいは，超売れっ子アイドルである． そんな彼女には，1つ苦手なものがある． 高いところだ・・・．彼女は，極度の高所恐怖症なのである． 彼女は今回，プロデューサーの不手際により，バラエティ番組で次のようなチャレンジに挑戦することになってしまった． 今回のロケは，とある忍者屋敷のとある一室で行われる． この部屋の床には，正方形のタイルが敷き詰められており，いくつかのタイルが抜け落ちて穴になっている． この穴から落ちると数メートル下の池にまっさかさまである． やよいのチャレンジ内容は，この部屋の指定された場所からスタートし，部屋の中に置かれた全ての巻物を回収し，ゴール地点まで持っていくことである． やよいは，部屋の中を以下のルールに従って移動できる． あるタイルから隣のタイルへ移動するとき，上下左右のタイルにのみ移動することができる． 穴に近くない場合，隣のタイルへ移動するためには，1秒だけ時間がかかる． 穴に近づいた場合，やよいは怖がってしまい図C-1のように移動時間がかかる．例えば，図中の矢印のように，[2][2]から[1][2]へ移動するためには，3秒かかる． 複数の穴が近くにある場合，最も近くにある穴に対して怖がる． 巻物を取るためにかかる時間は，0と仮定してよい． 図C-1: 穴の近くの移動時間 やよいは，なるべく早くこのチャレンジを終わらせたいと考えている． あなたの仕事は，このチャレンジを終了するための最短時間を求めるプログラムを書き，やよいを助けてあげることである． Input 忍者屋敷の床情報が与えられる． まず，1行目に部屋の大きさを表す， W と H がスペース区切りで入力される(2 <= W , H <= 100)． 続く H 行の各行には， W 文字の文字列が入力される． 床情報を表す文字には，以下の種類がある． '.' : 歩ける床 '#' : 穴 'S' : やよいが開始時に立っている場所 'G' : やよいが辿りつくべき場所 'M' : 巻物が置いてある場所 'S'と'G'と'M'は，歩ける床である． 'S'と'G'はそれぞれ，部屋の中にちょうど1個存在する．全ての巻物が揃っていない状態でゴールを通過しても構わない． 'M'は，部屋の中に最小で1個，最大で5個存在する． Output 全ての巻物を集めて，スタートからゴールへたどり着くための最短タイムを1行に出力せよ．入力データには，必ずそのようなルートがあると仮定してよい． 行の最後には，改行を出力すること． Sample Input 1 3 4 S.M ... ... M.G Sample Output 1 9 Sample Input 2 4 4 S..M .... ...# #..G Sample Output 2 18 Sample Input 3 11 7 M.........M ........... ...#.S.#... ........... ...#.G.#... ........... M.........M Sample Output 3 62
[ { "submission_id": "aoj_2419_10000626", "code_snippet": "#include \"bits/stdc++.h\" \n\nusing namespace std;\n\nvector<vector<int> > cst(110, vector<int>(110, 1)); \nint dist[110][110];\nint n, m;\n\nstruct node\n{\n int x, y, d;\n};\n\nvoid dejkstra(int x, int y)\n{\n queue<node> q;\n node p = ...
aoj_2416_cpp
K - XOR回廊 問題文 KU大学では一風変わったラリーゲームが人気である． このゲームの舞台であるサーキットには， N 個の休憩所と M 個の道があり， i 番目の道は f i 番目の休憩所と t i 番目の休憩所の間にある． すべての道にはチェックポイントが一つずつ存在し，道 i のチェックポイントを通過するとどちらの向きで通っても p i の得点がXORで加算される． XORで 加算される．大事なことなので2回言いました． このゲームでは，同じ休憩所や道を何度通っても良いし， ゴールにたどり着いてもそのままラリーを続行することができるが， 道の途中にあるチェックポイントを迂回して別の休憩所へ行くことは禁止されている． そのため，どのような道順をたどれば高い得点を取ることができるかを頑張って考えなければならない点が人気のある所以である． 今回は Q 人の参加者がいて， j 番目の参加者は a j の休憩所からスタートして，ゴールである b j の休憩所まで行くことになっているようだ． 運営側の人間としてそれぞれの参加者の最高得点を前もって調べておくことにした． 入力形式 入力は以下の形式で与えられる．なお休憩所の番号は0-indexedである． N M Q f 1 t 1 p 1 ... f M t M p M a 1 b 1 ... a Q b Q 出力形式 Q 行出力し， j 行目には a j 番目の休憩所から b j 番目の休憩所への経路で得られる得点の最大値を出力せよ． 制約 1 ≤ N ≤ 10 5 0 ≤ M ≤ 2 × 10 5 1 ≤ Q ≤ 10 5 0 ≤ f i , t i < N , f i ≠ t i 0 ≤ p i < 2 60 0 ≤ a j , b j < N どの休憩所からでも，道を辿っていけば任意の休憩所へたどり着ける． 休憩所 f i ,t i 間を結ぶ道は高々一つしか存在しない． 入力値はすべて整数である． この問題の判定には，60 点分のテストケースのグループが設定されている．このグループに含まれるテストケースは上記の制約に加えて下記の制約も満たす． M ≤ 20 入出力例 入力例1 5 5 3 0 1 7 1 2 22 2 3 128 3 4 128 4 2 128 0 1 0 0 3 4 出力例1 135 128 128 Writer : 森槙悟 Tester : 田村和範
[ { "submission_id": "aoj_2416_10307881", "code_snippet": "// AOJ #2416 XOR Cloister\n// 2025.3.17\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\n#define gc() getchar_unlocked()\n#define pc(c) putchar_unlocked(c)\n\nint Cin() { // 整数の入力\n\tint n = 0; int c = gc();\n\tif (c == '-'...
aoj_2422_cpp
Transparent Mahjong F: 透明な麻雀牌 あなたは，闇に舞い降りた天災と噂されるギャンブラーの鷹巣さんと麻雀で対局することになった． 鷹巣さんは天災と噂されるだけあって，鷹巣牌という奇怪な麻雀牌を用いた対局を提案してきた． 麻雀とは，プレイヤーが互いに手牌という複数枚の牌を持ち合い，自分の手牌を相手よりもはやく，アガリの形にすることで勝利が確定するゲームである． 麻雀の牌の表側には，その牌が何であるかが描かれており，牌の裏側には，何も描かれていない． よって，あなたが麻雀で対局するときは，あなたの手牌の表側をあなたの側に，裏側を対局者の側に向けるとよい． こうすることで，あなたの手牌が何であるかは，あなたのみが知ることができる． 麻雀の醍醐味は，プレイヤーが互の手配を読み合い，それを楽しむことにある． しかしながら，鷹巣牌は透明な麻雀牌である． 鷹巣牌は透明であるため，プレイヤーは互いに相手の手牌を知ることができる． これでは，手配の読み合いを楽しむことができない． 「もはや，これは麻雀ではない．」と，鷹巣牌を用いることに納得できないあなたは，鷹巣さんとの紆余曲折を経た協議の結果，鷹巣牌と普通の麻雀牌を混ぜて対局することになった． 手始めに，あなたは，鷹巣さんの手牌のアガリ牌が何であるかを予想することにした． 鷹巣さんの手牌は，鷹巣牌と普通の牌から構成される． 問題の簡単のため，鷹巣牌と普通の牌は，1から12の12種類各4枚からなるものとする． 3 n +2枚の牌からなる手牌について，次の3つの条件が満たされるとき，その手牌はアガリである． 同じ数字を組み合わせた牌の組が1つ存在する 残りの3 n 枚の牌は，3個の数字の組合せの n グループになる それぞれのグループは，同じ数字を3つ組み合わせたものか，3つの連続する数字を組み合わせたものである 例えば， 1 1 1 3 3 3 5 5 5 7 7 7 8 9 のような14枚の牌は，全て鷹巣牌で構成されている． この場合，次のように2つの牌の組合せ1つと4つのグループを作ることができ，アガリである． (1 1 1) (3 3 3) (5 5 5) (7 7) (7 8 9) 次に，普通の牌と鷹巣牌が混ざった手牌の例を挙げる． 1 1 1 3 3 3 5 5 5 7 7 7 * * のような14枚の牌は，12枚の鷹巣牌と2枚の普通の牌(*)で構成されている． この場合，次のように2つの普通の牌が8と9であるかもしれないので，2つの牌の組合せ1つと4つのグループを作ることができ，アガリであるかもしれない． (1 1 1) (3 3 3) (5 5 5) (7 7) (7 [8] [9]) 同じ例について，次のように2つの普通の牌が8と8であるかもしれないので，以下のような形のアガリであるかもしれない． (1 1 1) (3 3 3) (5 5 5) (7 7 7) ([8] [8]) しかし，7という同じ牌は4枚までしか使えないので，以下のような形のアガリであることはない． (1 1 1) (3 3 3) (5 5 5) (7 7 7) ([7] [7]) 鷹巣さんの3 n +1枚の手牌が入力として与えられたときに， 鷹巣さんの手牌に1枚の牌を加えて，3 n +2枚の手牌を作ることを考える． このときに，3 n +2枚の手牌がアガリになり得るような加える1枚の牌(アガリ牌)を全て求めよ． Input 入力は，次の形式で与えられる． n 牌 1 牌 2 ... 牌 3n+1 入力データは次の条件を満たす n は，0 <= n <= 15を満たす． 各牌は，鷹巣牌か普通の牌である．鷹巣牌の場合は，1以上12以下の整数で表され，普通の牌の場合は，文字*で表される． Output アガリ牌の一覧を昇順に出力せよ．アガリ牌を1つ出力する度に改行を出力せよ． あがり牌がない場合は，-1を1行に表示せよ． Sample Input 1 4 1 1 1 3 3 3 5 5 5 7 7 7 9 Sample Output 1 8 9 Sample Input 2 4 1 2 2 3 3 4 5 6 7 8 8 8 9 Sample Output 2 1 4 7 9 10 Sample Input 3 4 1 1 1 4 4 4 7 7 7 8 8 9 * Sample Output 3 6 7 8 9 10 11 Sample Input 4 4 1 * * * * * * * * * * * * Sample Output 4 1 2 3 4 5 6 7 8 9 10 11 12 Sample Input 5 1 3 * 1 4 Sample Output 5 1 2 4 5
[ { "submission_id": "aoj_2422_10342585", "code_snippet": "// AOJ #2422 Transparent Mahjong\n// 2025.4.2\n\n#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\n\nint n;\nvector<int> orig(13);\nunordered_map<string,bool> memo;\n\nstring enc(const vector<int>& f, int w, const vector<int>& a) ...
aoj_2421_cpp
Markup language has Declined E: マークアップ言語は衰退しました わたしたち人類がゆるやかな衰退を迎えて，はや数世紀． すでに地球は”ぷろぐらまー”のものだったりします． 平均身長170センチで7頭身，高い知能を持ち，こーでぃんぐが大好きなぷろぐらまーさんたち． わたしは，そんなぷろぐらまーさんと人との間を取り持つ重要な職，国際公務員の” えすいー ”となり，故郷のニブンキの里に帰ってきました． 祖父の年齢でも現役でできる仕事なのだから，さぞや楽なのだろうとこの職を選んだのですが…． ある日，ぷろぐらまーさんたちが渡してくれたのは，2枚の設計書のようなもの． そのぷろぐらまーさん曰く，テキストとスクリプトを利用して，様々な情報を容易に交換できるのだと言います． 1枚目の設計書は，文章構造を表すファイルの説明でした． このファイルのファイル名が.dmlで終わり，DMLファイルと呼ばれます． DMLファイルの中は，タグと呼ばれる文字列で挟むことで文章の構造を表しています． タグは，開始タグと終了タグが存在し， <開始タグ名>内容</終了タグ名> の要素で表されます． このとき，開始タグ名と終了タグ名は同じ文字列で表されます． タグは入れ子構造にすることができ，<tagA><tagB></tagB></tagA>のようにしても構いません． また，<tagA><tagB></tagA></tagB>のような構造は許されません． DMLファイル内のタグ名はいくつか特殊なものを除いて任意の文字列です． 特殊なタグは以下の5つです． タグ名：dml 全てのタグの根を表します． この開始タグは必ずファイルの先頭1度だけに現れ，このタグの終了タグはファイルの末尾に1度だけ出現します． タグ名：script 必ずdmlタグで囲まれた中で先頭，もしくはこの終了タグに連続して現れます． このタグは内部に入れ子構造を持つことが出来ません． このタグに囲まれたスクリプトファイルを関連付けます． このタグに囲まれた文字列は出力されません． タグ名：br 表示に際し，改行を行います． 終了タグを持ちません． タグ名：link このタグは内部に入れ子構造を持つことが出来ません． ユーザがこのタグに囲まれた文字列をクリックすると，現在の画面全てを消去し，その文字列で表されるファイル名のDMLファイルを表示します． タグ名：button このタグは内部に入れ子構造を持つことが出来ません． ユーザがこのタグに囲まれた文字列をクリックすると，scriptタグによって関連付けられているスクリプトの中から，その文字列で表される名前のサブルーチンを実行します． タグ名は，アルファベットの大文字，小文字のみで表されます． タグ名にスペースが現れることはありません． DMLファイル中に現れる文字列は，アルファベットの大文字，小文字，スペース，'<'，'>'，'/'となります． また，同名のタグが存在することもありえます． scriptタグ以外で囲まれたタグ以外の文字列は，画面の左上(0, 0)から左詰めで出力され， 画面端かbrタグが出現するまで改行されません． 2枚目の設計書は，DMLファイル中のボタンを押した時の動作を表すDSファイルの説明でした． DSファイルは，サブルーチンが並べられています． サブルーチン名 { 式; 式; ...; } セミコロンは式の終わりを表します． 例えば，DMLファイル中に，<title>?</title>で囲まれた文章があるとします． そのとき可能な式は以下の4つの代入式です． title.visible = true; title.visible = false; title.visible != true; title.visible != false; visibleへの真偽値の代入は，そのタグの内容を表示するかしないかを変更します．表示され無くなった場合には，それ以降の文章は左に詰められます． 最初やlinkタグのクリックによって現在表示しているDMLファイルが書き変わった時，初期値は全てtrueになっています． '!='は否定の代入を表します． 上の例では，1行目と4行目，2行目と3行目はそれぞれ等価です． また式は，以下のように複数の値を同時に変更することもできます． titleA.visible = titleB.visible = true; この時，右から順に処理が行われます． すなわち， titleB.visible = true; titleA.visible = titleB.visible; の2行と等価です． ただし，この表し方は便宜上であって，スクリプト内で文の最も右において，タグによる指定が行われることはありません． また， titleA.visible != titleB.visible = true; は titleB.visible = true; titleA.visible != titleB.visible; と等価です． タグの指定方法は，'.'で絞り込むことによって行われます． 例えば， dml.body.title は，dmlタグに囲まれた，bodyタグに囲まれた，titleタグを指します． ただし，scriptタグとbrタグが絞り込みにつかわれたり，指定されることはありません． このとき，絞り込まれる要素が直接囲まれているとは限らないことに注意して下さい． 例えば， <a><b><c></c></b></a> とあるとき，a.b.cでもa.cでもcを指すことができます． また，同名のタグが存在する場合には，指定されたタグが1つとは限りません． 指定したタグが存在しない場合には，表示に影響は与えられませんが，複数の値を同時に変更する際に現れた場合には，存在している場合と同様に評価されます． BNFは以下のようになります． <script_file> :: = <subroutine> | <script_file> <subroutine> <subroutine> ::= <identifier> '{' <expressions> '}' <expressions> ::= <expression> ';' | <expressions> <expression> ';' <expression> ::= <visible_var> '=' <visible_exp_right> | <visible_var> '!=' <visible_exp_right> | <visible_var> '=' <expression> | <visible_var> '!=' <expression> <visible_exp_right> ::= 'true' | 'false' <visible_var> ::= <selector> '.visible' <selector> ::= <identifie ...(truncated)
[ { "submission_id": "aoj_2421_2997905", "code_snippet": "#include <cstdio>\n#include <cstdint>\n#include <cctype>\n#include <cassert>\n#include <algorithm>\n#include <vector>\n#include <string>\n#include <map>\n#include <regex>\n\n#define fprintf(...) void(0)\n\nstd::string join(const std::vector<std::string...
aoj_2420_cpp
Anipero 2012 D: アニペロ2012 アニペロサマーライブ，通称アニペロは，さまざまなアニメソングアーティストたちが集結する，日本国内最大のアニメソングライブイベントである．アニソンが大好きな2D君は，昨年に引き続き，今年もアニペロに行くことにした． 彼は，アニペロを楽しむために，すでにサイリウムを m 本購入している．サイリウムとは，折ると化学反応で光るスティックである．リズムに合わせてサイリウムを振ることで，ライブを盛り上げることができ，自分の満足度も上昇する．今回，彼が購入した全てのサイリウムは，次のような性質を持つ． サイリウムは，折ってから時間が経過するにつれ暗くなっていき，10分で光を失う． 折ってから5分の間は，非常に明るい（以下，「レベル2」と呼ぶ）． 折ってから5分経過した後は，少し暗くなる（以下，「レベル1」と呼ぶ）． 振っても振らなくても，光を失うスピードは変わらない． 2D君は，限られたサイリウムを曲によってうまく使い分けることで，今年のアニペロでどれだけの満足度を得られそうか，以下の問題を考えることにした． 彼は，ライブ中に流れるであろう曲を n 曲予想している． 各曲の長さは，全て5分である． n 曲は，連続で流れ続け，曲と曲の間は，0分と考えてよい． 各曲には，以下の3つのパラメータが与えられる． ある曲に対して，レベル2を1本だけ振ったときに増える満足度 ある曲に対して，レベル1を1本だけ振ったときに増える満足度 ある曲において，1本も振らないときに増える満足度 サイリウムを振ったからといって，満足度が増えるとは限らない． 振ったら逆に会場の雰囲気を乱して，満足度が減る場合もある． 振らない場合も，同様のことが言える． サイリウムは，以下のルールに従って使用しなければならない． 曲が始まる時点でのみ折ることができ，一度に何本でも折ることができる．サイリウムを折るのにかかる時間は無視してよい． 1曲で最大8本同時に振ることができる． 複数のサイリウムを振る際，以下の式により加算する満足度を計算する． (レベル1の本数)×(レベル1の1本あたりの満足度)＋(レベル2の本数)×(レベル2の1本あたりの満足度) 1本もサイリウムを振らない場合は，1本も振らない場合の満足度だけを加算する． 一度振ると決めたサイリウムは，1曲が終了するまで持ち替えることはできない． サイリウムは，振らずに置いておくことができる．また，サイリウムを全て使いきる必要はない． 2D君は，ライブの曲予想までは済ませたが，それだけで疲れてしまって，問題を解く気になれなかった． あなたの仕事は，彼の代わりに，今年のライブで得られそうな最大満足度を求めるプログラムを書くことである． Input ライブの予想曲リストに対する満足度情報が入力される． 1行目に，ライブで歌われる曲数 n (1 <= n <= 50)と，ライブ開始時に2D君が持っている新品のサイリウムの数m (0 <= m <= 50)がスペース区切りで入力される． 続く n 行では，1行ずつ1曲の情報が入力される． i 番目(1 <= i <= n )の曲情報は， 曲 i に対して，レベル2のサイリウムを1本振ったときの満足度 a i 曲 i に対して，レベル1のサイリウムを1本振ったときの満足度 b i 曲 i において，サイリウムを1本も振らないときの満足度 c i がスペース区切りで入力される(-100 <= a i , b i , c i <= 100)． Output ライブ終了時の2D君の最大満足度の予想を1行に出力せよ． 最大満足度がマイナスになることもあるので，注意すること． 行の最後には，改行を出力すること． Sample Input 1 1 5 2 3 8 Sample Output 1 10 Sample Input 2 2 10 2 2 20 2 3 -10 Sample Output 2 44 Sample Input 3 3 10 5 1 9 -3 2 1 1 11 0 Sample Output 3 102
[ { "submission_id": "aoj_2420_2967017", "code_snippet": "#include<iostream>\n#include<vector>\n#define VAL 55\nusing namespace std;\nusing lli = long long int;\nlli dp[VAL][VAL][VAL][VAL]; // 曲，サイリウム数，状態1，状態2\n\nint main(){\n int n, m;\n std::cin >> n >> m;\n for (int i = 0; i < VAL*VAL*VAL*VAL; i++) {\n ...
aoj_2425_cpp
全探索お姉さんの休日 全探索お姉さんはとても優秀な女性である。 お姉さんは格子状の道の経路の数え上げを数千程度なら簡単に数え上げてしまう。 あなたと全探索お姉さんは今、六角形のタイルが敷き詰められた部屋にいる。 お姉さんは初めて見る六角形にとても興奮している様子である。 六角形の並びを座標に表すことに不慣れなお姉さんは図1のような座標系で部屋を表した。 図1 あなたはこの座標系上である地点からある地点まで移動したい。 しかし、お姉さんは 1 分ごとに動きたい方向をあなたに指示する。 いつものお姉さんなら同じ座標の場所を通らないようにあなたに移動の指示を出すだろう。 しかし、この座標系に不慣れなお姉さんは |x×y×t| ( x ： x 座標、 y ： y 座標、 t :最初の指示からの経過時間[分])を 6 で割った余り に対応する方向（図で示す番号と対応）を指示するだけで、まったくのでたらめな方向にあなたを誘導する。 図2 お姉さんを傷つけたくないあなたは、お姉さんの指示をできるだけ守りつつ目的地までたどり着きたい。 あなたは許された行動は下の 7 つの行動である。 方向 0 へ 1 タイル移動 方向 1 へ 1 タイル移動 方向 2 へ 1 タイル移動 方向 3 へ 1 タイル移動 方向 4 へ 1 タイル移動 方向 5 へ 1 タイル移動 その場に留まる お姉さんが指示を出した直後にあなたはこれら行動のうちの必ず1つを行う。 部屋には家具があり家具が配置されているタイルの中に移動することはできない。 また、 y 座標の絶対値が ly を超えたり x 座標の絶対値が lx を超えるような移動は許されていない。 しかし、お姉さんはそのような移動を指示することがある。 指示を無視するとはお姉さんが示した方向と異なる方向へ移動するか、 もしくは、その場に留まることである。 目的地にたどり着くために最小で何度指示を無視すれば良いかを出力せよ。 目的地にたどり着くことが不可能な場合は -1 を出力せよ。 Input 入力は以下の形式で与えられる。 sx sy gx gy n x 1 y 1 ... x i y i ... x n y n lx ly ここで、 sx , sy は出発地点の座標 gx , gy は目的地の座標 n は部屋に配置されている家具の数 x i , y i は家具があるタイルの座標 lx , ly は移動できる X , Y それぞれの座標の絶対値の上限 である。 Constraints 入力はすべて整数 -lx ≤ sx , gx ≤ lx -ly ≤ sy , gy ≤ ly (sx, sy) ≠ (gx, gy) (xi, yi) ≠ (sx, sy)(1≤i≤n) (xi, yi) ≠ (gx, gy)(1≤i≤n) (xi, yi) ≠ (xj, yj)(i ≠ j) 0≤ n ≤ 1000 -lx ≤ xi ≤ lx (1≤i≤n) -ly ≤ yi ≤ ly (1≤i≤n) 0 < lx, ly ≤ 100 Output 出力は1つの整数を含む1行で出力せよ。 目的地にたどり着ける場合は、最小の指示を無視する回数を出力せよ。 目的地にたどり着くことが不可能な場合は-1を出力せよ。 Sample Input 1 0 0 0 2 0 2 2 Output for the Sample Input 1 0 Sample Input 2 0 0 0 2 6 0 1 1 0 1 -1 0 -1 -1 -1 -1 0 2 2 Output for the Sample Input 2 -1 Sample Input 3 0 0 0 2 1 0 1 2 2 Output for the Sample Input 3 1
[ { "submission_id": "aoj_2425_10914251", "code_snippet": "#include<bits/stdc++.h>\n// #include<atcoder/all>\n// #include<boost/multiprecision/cpp_int.hpp>\n\nusing namespace std;\n// using namespace atcoder;\n// using bint = boost::multiprecision::cpp_int;\nusing ll = long long;\nusing ull = unsigned long lo...
aoj_2426_cpp
宝探し 太郎君はある広場にお宝を探しにやってきました。この広場にはたくさんのお宝が埋められていますが、太郎君は最新の機械を持っているので、どこにお宝が埋まっているかをすべて知っています。広場はとても広いので太郎君は領域を決めてお宝を探すことにしましたが、お宝はたくさんあるためどのお宝がその領域の中にあるかすぐにわかりません。そこで太郎君はその領域の中にあるお宝の数を数えることにしました。 Input n m x 1 y 1 x 2 y 2 ... x n y n x 11 y 11 x 12 y 12 x 21 y 21 x 22 y 22 ... x m1 y m1 x m2 y m2 n は広場に埋まっているお宝の数を表す m は調べる領域の数を表す 2行目から n+1 行目はそれぞれのお宝が埋まっている座標を表す n+2 行目から n+m+1 行目はそれぞれの調べる領域を表す x軸の正の方向が東、y軸の正の方向が北を表す それぞれの領域は長方形であり、 x i1 と y i1 は長方形の南西の頂点の座標、 x i2 と y i2 は長方形の北東の頂点の座標を表す Constraints 1 ≤ n ≤ 5000 1 ≤ m ≤ 5×10 5 |x i |, |y i | ≤ 10 9 (1 ≤ i ≤ n) |x i1 |, |y i1 |, |x i2 |, |y i2 | ≤ 10 9 (1 ≤ i ≤ m) x i1 ≤ x i2 , y i1 ≤ y i2 (1 ≤ i ≤ m) すべての入力は整数で与えられる Output C 1 C 2 ... C m それぞれの領域に含まれるお宝の数を各行に出力せよ Sample Input 1 3 1 1 1 2 4 5 3 0 0 5 5 Output for the Sample Input 1 3 領域の境界線上にあるお宝も領域に含まれるものとみなす Sample Input 2 4 2 -1 1 0 3 4 0 2 1 -3 1 5 1 4 0 4 0 Output for the Sample Input 2 2 1 領域は直線や点のようになる場合もある Sample Input 3 2 3 0 0 0 0 -1 -1 1 1 0 0 2 2 1 1 4 4 Output for the Sample Input 3 2 2 0 同じ場所に複数のお宝が存在する場合もある Sample Input 4 5 5 10 5 -3 -8 2 11 6 0 -1 3 -3 1 3 13 -1 -1 9 5 -3 -8 10 11 0 0 5 5 -10 -9 15 10 Output for the Sample Input 4 2 2 5 0 4
[ { "submission_id": "aoj_2426_11043154", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\nusing ll = long long;\nusing a2 = array<int, 2>;\nusing a3 = array<ll, 3>;\n\nbool chmin(auto& a, const auto& b) { return a > b ? a = b, 1 : 0; }\nbool chmax(auto& a, const auto& b) { return a < b ? a = ...
aoj_2427_cpp
ほそながいところ 高橋君は苹果(りんご)ちゃんとニューヨークを観光することになりました。 高橋君は観光するところに特に希望はなかったのですが、苹果ちゃんの熱烈な誘いにより、以下の地図にあるような"ほそながいところ"を観光することに決まりました。 Google マップ - (C)2012 Google この"ほそながいところ"はとても細長く、直線とみなすことができます。また、"ほそながいところ"には片方の端にスタート地点が、もう片方の端にゴール地点があり、スタート地点からゴール地点へ向けて何台かの観光用の馬車が走っています。この馬車は以下のようなルールに従って運行されています。 馬車は n 台あり、すべての馬車はスタート地点から出発してゴール地点まで進みます。 以下のすべての場合において馬車の大きさは無視できます。 途中で速度を変更することが難しいため、すべての馬車は馬車はそれぞれ1kmあたりを S i ( S i は1以上の整数)分の等速で進みます。 馬車には出発する順番が定められており、この順番を守らなければなりません。ただし、ゴール地点に到着する順番について特に決まりはありません。 複数の馬車はスタート地点を同時に発車することはできず、ある馬車が発車すれば次の馬車が発車するまでに1分以上間をあけなければなりません。 ゴール地点は十分に広いため、何台の馬車が同時に到着しても構いません。また、ゴール地点に到着した馬車はそこで止まり、ずっとゴール地点にいます。 "ほそながいところ"は大変細長いため馬車は基本的に同じ場所に2台並ぶことはできません。しかし、特別に"すこしひろいところ"が m 箇所あり、そこでのみ2台まで並ぶことができ、ある馬車が別の馬車を追い抜くことが可能です。 また、先述した"ほそながいところ"と"すこしひろいところ"について、以下の制約を満たします。 スタート地点からゴール地点までは直線的に結ばれており、その距離は( dist )km( dist は1以上の整数) m 箇所の"すこしひろいところ"はスタート地点からゴール地点までのどこかにあり、それらはいずれもスタート地点およびゴール地点とは重なりません。また、それぞれの"すこしひろいところ"はスタート地点からちょうど( D i )km( D i は1以上の整数)の地点にあります。 これを聞いた高橋君は、以上に述べた馬車運行のルールを守りつつ馬車の出発時刻を調整することにより、1台目の馬車が発車してからすべての馬車が到着するまでにかかる時間を小さくできることを見抜きました。 高橋君の出した結果を知るために、 馬車の台数 n , それぞれの馬車の速度に関するパラメータ S i ,"ほそながいところ"上に存在する"すこしひろいところ"の総数 m ,それぞれの"すこしひろいところ"のスタート地点からの距離 D i が与えられるので、 1台目の馬車が発車してからすべての馬車が到着するまでにかかる時間の最小値を求めるプログラムを書くことがあなたの仕事です。 なお、苹果ちゃんは"ほそながいところ"での観光を存分に楽しみましたが、高橋君はこの観光の後には「ほそながかった…」としかつぶやかなかったそうです。 Input 入力形式は以下のようになっている。 dist n S 1 S 2 .. S n m D 1 D 2 .. D m dist はスタート地点からゴール地点までの距離(km)を表す n はスタート地点を発車する馬車の数を表す S i は馬車の速度を表し、 i 番目に出発する馬車は1kmを (S i ) 分で進むことを表す。 m は"すこしひろいところ"の総数を表す D i はスタート地点からそれぞれの"すこしひろいところ"への距離(km)を表す。 Constraints 1≤dist≤100000000(10 8 ) 1≤n≤5 0≤m≤5 1≤S i ≤100 0<D i <dist i≠j ならば D i ≠D j 入力に出現する数はすべて整数である。 i < j ならば、 i 番目に出発する馬車は j 番目の馬車より1分以上早く出発しなければならない Output 1台目の馬車が発車してからすべての馬車が到着するまでにかかる時間の最小値を1行に出力せよ。単位は分である。 Sample Input 1 100 2 1 2 0 Output for the Sample Input 1 201 2台目は1台目が出発した1分後に出発する。 Sample Input 2 100 2 2 1 0 Output for the Sample Input 2 200 2台目は1台目が出発した100分後に出発し、ゴールで1台目に追いつく。 Sample Input 3 100 3 2 1 1 1 50 Output for the Sample Input 3 200 2台目は1台目が出発した50分後に出発し、50mのひろいところで1台目を抜く。 3台目は1台目が出発した100分後に出発し、ゴールで1台目に追いつく。 Sample Input 4 100 4 3 1 1 3 2 40 60 Output for the Sample Input 4 421
[ { "submission_id": "aoj_2427_8309365", "code_snippet": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nlong long Answer = (1LL << 62);\nlong long Dist;\nlong long N, S[19];\nlong long M, D[19];\nlong long Memo[19];\nlong long NumOrder;\nvector<pair<int, int>> Order[100...
aoj_2428_cpp
失われし数 時は3xxx年、高度に発達した文明は停滞期を迎えていた。歴史家たちはこの状況を打開しようと過去の叡智を学ぶことにした。注目したのはコンピュータ創世期の天才が残した資料である。この資料には計算式が書かれておりその計算結果が知りたいのだが、残念ながらその一部の文字が薄れて読めなくなっている。仕方がないので計算結果としてありえる最も大きい数を求めることにした。 計算式は2進数で書かれており、演算は足し算・引き算・掛け算の3種類である。括弧も用いられているが括弧内が数字のみであることはない。正確には以下のBNFで定義された文法を満たしている必要がある。 <expression> ::= <number> | <expression> <operation> <expression> | ( <expression> <operation> <expression> ) <number> ::= <digit> | <number> <digit> <operation> ::= + | - | * <digit> ::= 0 | 1 当時のコンピュータの計算能力の限界により、数字は0以上 2 10 未満の整数であり計算中もこの範囲を出ることはない。ただし計算は括弧内を先に行い、掛け算は足し算・引き算より先に行う。それ以外の場合は左から順に計算する。 Input 入力は1行からなり、解読すべき数式が1つ与えられる。数式は1文字以上100文字以下である。1つの数式について最大5文字が読めなくなっていて、「.」で表現されている。与えられる数式に含まれる文字は01+-*().のいずれかである。 Constraints 数式は1文字以上100文字以下 改行を除くすべての文字は01+-*().のいずれか .の個数は5個以下 Output 元の数式として考えられるものの内、計算結果が最大となるものを求め、計算結果を10進法で出力せよ。読めなくなっている文字をどのように埋めても元の数式と考えられるものを作れないときは-1を出力せよ。 Sample Input 1 000 Output for the Sample Input 1 0 Sample Input 2 0.0 Output for the Sample Input 2 2 Sample Input 3 ... Output for the Sample Input 3 7 Sample Input 4 (1.1) Output for the Sample Input 4 2 Sample Input 5 0-1. Output for the Sample Input 5 -1
[ { "submission_id": "aoj_2428_10854054", "code_snippet": "#include <bits/stdc++.h>\n#include <stdlib.h>\nusing namespace std;\n\nusing ll = long long;\nusing pll = pair<ll, ll>;\n \nconstexpr ll M = 1e9+7;\n\nconst string w = \"01+-*()\";\n\nconstexpr int mi = 0;\nconstexpr int ma = 1023;\n\nbool isrange(int...
aoj_2429_cpp
まるかいて 太郎君は小学生で、チラシの裏に落書きをしています。 ある時、太郎君は次のゲームを思いつきました。 n×n の格子状のマス目を書いておきます。 それぞれのマス目の初期状態は、丸印が書かれているか、書かれていないかのどちらか一方です。 これらの丸印を消したり書いたりして最終的にどの一列を見ても必ずちょうど1つのみの丸印が、どの一行を見ても必ず1つのみの丸印が存在するようにすることが目標であり、この状態にすればゲームをクリアしたことになります。 太郎君はこのゲームを思いつきましたが、太郎君はこのゲームをクリアするのに大変時間がかかってしまいます。そこで、大学生であるあなたに助けを求めました。 太郎君の兄であり大学生であるあなたの仕事は以下の通りです。 厳密な状況を考えるために、あるマス目に丸印を書き込むコスト、あるマス目にある丸印を消すコストをあなたは導き出しました。このコストを用いてこのゲームをクリアするためにかかる操作のコストを最小化するような手順を考える。 このとき、最小のコストおよびそのコストを達成するような手順を出力するプログラムを書いてください。 出力については、最小コストを達成する手順なら、どのような操作、順番でも出力してもよいものとする。 Input n W 11 W 12 .. W 1n W 21 W 22 .. W 2n .. W n1 W n2 .. W nn E 11 E 12 .. E 1n E 21 E 22 .. E 2n .. E n1 E n2 .. E nn F 1 ( n 文字) F 2 ( n 文字) .. F n ( n 文字) n は太郎君の作ったマス目が一辺にいくつあるかを表す W ij は上から i 番目、左から j 番目のマス目に丸印を書き込むコストを表す E ij は上から i 番目、左から j 番目のマス目に書かれてある丸印を消すコストを表す F i は上から i 番目の行のマス目の初期状態を表す F i の左から j 文字目について 'o'のとき、上から i 番目、左から j 番目のマス目に丸印が書かれてあることを表す。 '.'のとき、上から i 番目、左から j 番目のマス目が空白であることを表す。 Constraints 1≤ n ≤ 100 1≤ W ij ≤ 1000 1≤ E ij ≤ 1000 F i は文字列であり、その長さは n である F i は'o'と'.'のみで構成されている Output mincost cnt R 1 C 1 operate 1 R 2 C 2 operate 2 .. R cnt C cnt operate cnt mincost は、太郎君のゲームをクリアするために必要な最小コストを表す。 mincost は書き込み操作、消去操作で発生するコストの総和で計算される。 cnt : mincost のコストを達成する操作を行った回数を表す k 回目 (1≤k≤cnt) に実行する操作は k+2 行目に記述する k 回目 (1≤k≤cnt) の操作に対して 上から i 番目のマス目、左から j 番目のマス目に対して行ったものとすると R k k である。 この操作が丸印を消す操作であるならば operate k = "erase"とせよ この操作が丸印を書き込む操作であるならば operate k = "write"とせよ R k ,C k ,operate k は一行に空白区切りで出力しなければならない 丸印の書かれてあるマス目に対して丸印を記述する操作、および丸印が書かれていないマス目に対して丸印を消去する操作をした場合はWrongAnswerである cnt 個の操作にかかるコストの総和が mincost に一致しないときはWrongAnswerである Sample Input 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 o.o ... .o. Output for the Sample Input 1 2 2 1 3 erase 2 3 write 上から1番目、左から3番目のマス目の丸印を消去し、 上から2番目、左から3番目のマス目に丸印を書き加えれば目標は達成できる。 このときコストは2のみしかかからず、これが最小のコストである。 Sample Input 2 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 oooo oooo oooo oooo Output for the Sample Input 2 30 12 1 1 erase 1 2 erase 1 3 erase 2 1 erase 2 2 erase 2 4 erase 3 1 erase 3 3 erase 3 4 erase 4 2 erase 4 3 erase 4 4 erase コスト(1+2+3+4)*3だけ消去処理をすればクリアとなります。 Sample Input 3 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 o.. .o. ..o Output for the Sample Input 3 0 0 すでに目標は達成されているため、コスト及び操作回数はともに0となる。
[ { "submission_id": "aoj_2429_9723846", "code_snippet": "#include <bits/stdc++.h>\n#define INF 1e9\nusing namespace std;\n\nconst int MAX_N = 100; // Максимальное количество вершин\nconst int MAX_V = 1000; // Максимальное количество вершин в сети\n\nstruct Edge {\n int to, cap, cost, rev;\n};\n\nint n, N...
aoj_2430_cpp
最長増加列問題 時は過ぎて太郎君は高校生になりました。 大学生だったお兄さんの影響も受け、コンピューターサイエンスに興味を持ち始めました。 太郎君はコンピューターサイエンスの教科書を読み進め、「最長増加部分列問題」という有名問題があることを知りました。太郎君はこの問題のことを理解しましたが、自分でも類似問題が作れないものかと気になりました。 そこで太郎君は試行錯誤の結果に次のような問題を作りました。 n 個の整数で構成される数列Aがある m-1 個の区切りを入れて、数列Aを m 個の数列に分解する。なお、分解後のそれぞれの数列は1つ以上の数を必ず含まなければならない。 この m 個それぞれの数列内の整数をすべて足し合わせた結果出来上がる m 個の数を、元の数列の順に配置すると厳密な増加列になっている(つまり、出来上がる数列は B i < B i+1 をみたす)ようにしたい。 目標は最終的にできる数列 B の長さ m を最大化することである。 例えば、数列 A が{5,-4,10,-3,8}の場合を考えてみる。 区切りの位置を表す数列 C を用意し、 C={2,4} とする。 このとき、数列 A は(5,-4),(10,-3),(8)の部分に分かれ、これらの内部を足し合わせるとそれぞれ1,7,8となり、出来上がる数列 B は{1,7,8}となる。 太郎君はこの問題について"最長増加列問題"と名付け、これを解くアルゴリズムも考えました。 そして社会人になったあなたにチェックをしてほしいと連絡をしました。 あなたの仕事は、成長した太郎君の作った問題を解くプログラムを作ることです。 チェックするのが仕事なので、 m-1 個の区切りの位置も出力します。 なお、最適な m に対してこのような区切り方が複数考えられる場合もありますが、この m が正しく出力されていれば、考えられるもののうち一つを出力すればよいです。 Input 改行区切りで n+1 個の整数が与えられる。 n A 1 A 2 ... A n n は与えられる数列 A の長さを表す A i は数列 A のi番目の要素を表す。 Constraints 1≤n≤4000 |Ai|≤ 10 8 整数 k に対して |k| は k の絶対値を表す Output m C 1 C 2 .. C m-1 1行目は一つの整数 m を出力する。 m は最終的にできる数列 B の長さを表す。 2行目は m-1 個の整数 C i を空白区切りで出力する。 C i は、数列 A を m 個の部分に適切に区切った時の i 番目の区切り場所を表す。 区切り場所の定義は図を参照せよ。なお、 1≤C i <n を満たす。 2行目の m-1 個の整数列Cは昇順に並んでいなければならないしたがって、 i < j ならば C i < C j が成立する。 m=1 の場合2行目は空行になる。 数列 C に従って数列 A から数列 B を生成したとき、数列 B が増加列になっていないとき(すなわち B i ≥B i+1 となる i(1≤i<m) が存在するとき)、WrongAnswerとなる Sample Input 1 3 1 2 4 Output for the Sample Input 1 3 1 2 もともと増加列なので、すべての場所に区切りを入れればよい Sample Input 2 3 2 2 2 Output for the Sample Input 2 2 1 2 2 2は増加列でないので、3つに分割することはできない Sample Input 3 3 4 2 1 Output for the Sample Input 3 1 (空行) どう分割しても増加列にはならないため、分割をしない
[ { "submission_id": "aoj_2430_8323868", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\n#define rep(i, n) for (int i = 0; i < (n); i++)\n#define per(i, n) for (int i = (n)-1; i >= 0; i--)\n#define rep2(i, l, r) for (int i = (l); i < (r); i++)\n#define per2(i, l, r) for (int i = (r)-1; i >=...
aoj_2431_cpp
引越し 太郎君は引っ越しをすることになりました。太郎君はたくさんの荷物を持っているので、荷物の運搬を引っ越し業者に頼むことにしました。荷物はいろいろな重さの物があるので、わかりやすいように軽い方から順番に並べて置いてもらうように頼みましたが、引っ越し業者の人はばらばらの順番で荷物を置いていってしまいました。そこで太郎君は荷物を並べ替えようとしましたが、荷物は重いので運ぶのには体力が必要です。それぞれの荷物は今ある場所から他の荷物の間や荷物の端など好きな場所に運ぶことができますが、ある荷物を運ぶにはその荷物の重さと同じだけ体力を使います。太郎君はあまり体力がないので、できるだけ体力を使わずに荷物を軽い方から順番に並べる方法を考えることにしました。 Input n x 1 x 2 ... x n n は太郎君の持っている荷物の数を表す x 1 から x n はそれぞれの荷物の重さを表し、現在は x 1 、 x 2 、…、 x n の順に並んでいる Constraints 1 ≤ n ≤ 10 5 1 ≤ x i ≤ n (1 ≤ i ≤ n) x i ≠ x j ( 1 ≤ i, j ≤ n かつ i ≠ j ) 入力はすべて整数で与えられる Output S 荷物を軽い方から順番に並べるのに必要な最小の体力の合計 S を出力せよ、ただし最後に改行を出力せよ Sample Input 1 4 1 4 2 3 Output for the Sample Input 1 4 重さ4の荷物を右端に運ぶと重さの軽い順になります Sample Input 2 5 1 5 3 2 4 Output for the Sample Input 2 7 重さ2の荷物を重さ1の荷物の右側に運び、重さ5の荷物を右端に運ぶと重さの軽い順になります Sample Input 3 7 1 2 3 4 5 6 7 Output for the Sample Input 3 0 最初から重さの軽い順に並んでいます Sample Input 4 8 6 2 1 3 8 5 4 7 Output for the Sample Input 4 19
[ { "submission_id": "aoj_2431_10506310", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n#define all(v) (v).begin(),(v).end()\n#define pb(a) push_back(a)\n#define rep(i, n) for(int i=0;i<n;i++)\n#define foa(e, v) for(auto&& e : v)\nusing ll = long long;\nconst ll MOD7 = 1000000007, MOD998 = ...
aoj_2423_cpp
Code Art Online G: コードアートオンライン コードアートオンライン（CAO）は，様々な問題をプログラミングによって解くことにより，冒険を進めて行くオンラインRPGである． CAOは，世界初のバーチャルリアリティ空間を実現したゲームであったこともあり，大人気の内に完売し，ゲームを購入したユーザ達はこの世界を楽しむはずであった． しかし，ゲームにダイブしたプレイヤー達は，ゲームマスターから恐るべき託宣を聞かされる． 「君たちプレイヤーの内の誰かが，ラストダンジョンのラストプロブレムを解かない限り，この仮想空間から抜け出すことはできない．そして，この世界での，WAやTLE・REは，現実世界での死を意味する．心して問題にとりかかってほしい．」 あなたも，CAOのプレイヤーの内の1人で，このゲームをクリアして現実世界に戻るために，ゲーム攻略に全力を尽くしている． ある日，あなたは次のような問題に直面することとなった． 今回，新たなダンジョンを攻略するために， n 人のメンバーでパーティが組まれた． あなたもこのパーティの内の1人である． 今から攻略するダンジョンに突入するためには，崖から見える穴を通過しなくてはならない． 無事に穴を通過できれば，ダンジョンに突入できるが，穴に突入できず他の部分に触れてしまうと，死が待っている． さらに，1つの穴に誰かが通ると，その穴は閉じてしまうため，1人1人別々の穴に入らなければならない． 穴や人は，二次元平面上で考えることとする． 穴の形は，図G-1のような，大小様々な円である．入力では，半径の長さが与えられる． 図G-1: 穴の形 人の形は，図G-2のように人の断面が多角形で与えられる（凸とは限らない）． 入力では，多角形の形を表すために，頂点が反時計まわりで与えられる． 多角形の任意の三点は，1直線上に並ばないと仮定してよい． さらに，頂点を構成する目的以外で，多角形の線分同士が交差することはないものとする． 穴に通すために，自由に回転してよい（ただし，z軸方向への回転は禁止する）． 人を表す多角形の頂点が，穴の円周上にある場合でも，穴を通過できるものとする． 図G-2: 人の形 パーティの中で最もアルゴリズムスキルが高いあなたは，みんなで無事に穴を通過できるかどうかの判定問題を解くことにした． もし，無事に通過できるなら，どの人がどの穴を通過すればいいのか表示せよ． ※今回のコンテストで死ぬことはありませんが，間違ったら死ぬつもりで解いてください． Input 1行目に，穴の数を表す整数 n (1 <= n <= 100)と，パーティの人数を表す整数 m (1 <= m <= n )がスペース区切りで入力される． 次の行に，穴の半径を表す整数 r i (1 <= r i <= 1000)がスペース区切りで n 個入力される． これらの穴は，入力された順番に，1番の穴, 2番の穴, ..., n 番の穴と数えることとする． 続いて， m 人の人の形の情報が入力される． 1人の情報は，まず1行目に多角形の頂点数 p (3 <= p <= 100)が入力される． 続く p 行には，多角形の頂点の座標が反時計周りで与えられる． 各行には，1つの頂点を表す整数 x i , y i (-1000 <= x i , y i <= 1000)がスペース区切りで入力される． 人は，入力された順番に，1番の人, 2番の人, ..., m 番の人と数えることとする． Output i 番(1 <= i <= m )の人が，何番の穴に入ればいいかを出力せよ． i 行目には， i 番の人が通るべき穴の番号を出力すること． もし，複数の通り方がある場合，辞書順で一番小さくなる通り方を出力すること． 2つの数列 A = { a 1 , a 2 , ..., a m }と B = { b 1 , b 2 , ..., b m }があったとき， A が B より辞書順で小さいとは， a i が b i と異なるような最初の i について， a i が b i より小さいときのことを言う． 通り方が1つも見つからない場合は，"NG"と1行出力すること． 最後に改行を出力するのを忘れないこと． Sample Input 1 3 3 25 100 10 8 -10 0 -2 2 0 10 2 2 10 0 2 -2 0 -10 -2 -2 4 30 0 50 0 50 40 30 40 3 30 -10 45 -70 60 -10 Sample Output 1 3 1 2 Sample Input 2 4 3 25 15 15 30 5 0 0 10 0 20 10 0 20 -20 10 3 20 0 40 0 30 10 3 -50 0 -30 0 -40 10 Sample Output 2 1 2 3 Sample Input 3 2 2 1 30 4 0 0 10 0 10 10 0 10 3 5 5 20 20 5 20 Sample Output 3 NG
[ { "submission_id": "aoj_2423_8818854", "code_snippet": "#define _CRT_SECURE_NO_WARNINGS\n#include <algorithm>\n#include <cmath>\n#include <cstdio>\n#include <cstring>\n#include <ctime>\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <utility>\n#include <vector>\nusing namespace std;\nt...
aoj_2424_cpp
かけざん 太郎君はかけざんを習いたての小学生です。なんとなく、彼はかけざんを気に入っているので、数字を見かけるとかけざんをしたくなります。そんな彼はここのところ、次のような処理を0以上の整数に施すことが好きなようです。 (処理の流れ) 手順1. ある0以上の整数nが10進数表示で一けたならばそこで処理を終了する。そうでなければ手順2に進む 手順2. 10以上の整数nを10進数表示をするとどこかの桁の間に切れ目を入れて二つの数字に分解することが可能である(例えば2012-> 20,12)。このような切り方としてありうるものに対して,得られた二つの数字を掛け合わせて最も大きいものを次のnとして手順1に戻る。(詳しくは下記の"手順2に関する補足を参照") 太郎君はこの処理を気に入っているようですが、何回手順2の操作を繰り返せばよいのか大きい数字だと予想ができず、もしかしたら無限回行われなければならないかもしれないと思っています。そこで、太郎君の兄であり大学生であるあなたに0以上の整数nに対してこの手順2を何回しなければならないかを聞いてきました。 あなたの仕事は、Q個の0以上の整数 N 1 .. N Q が与えられるので、それぞれの整数で処理の終了までに何回の手順2が施されるかを求めることです。その際にもし無限回の手順が必要ならば、-1を出力してください。 手順2に関する補足 切り分けた結果、桁の初めに0がつくものも考慮に入れる必要があります。 例えばn=1024のとき、1*024 , 10*24 , 102*4をそれぞれ計算するとそれぞれ24,240,408となるため、408が選ばれ、これが次のnとなります。 Input Q N 1 N 2 ... N Q Q は与えられる0以上の整数の個数を表す N i は太郎君が気になっている0以上の整数で,i番目のものを表す Constraints 1≤Q≤100 0≤N i ≤10 6 Output Q 個の整数を改行区切りで出力せよ R 1 R 2 .. R Q R i は、 N i に対して処理を終了するまでに手順2を実行する回数を表す N i に対して手順2を無限回だけ実行する必要がある場合は R i は -1となる Sample Input 1 3 9 99 123 Output for the Sample Input 1 0 2 3 9は1桁の数なので、手順2が実行されることはありません。 99は2桁であり、手順2を施せば9,9としか分割できずその次の数は81となる。 81も2桁の数であり、手順2を施せば8,1としか分割できずその次の数は8となる。 1桁の数になったので処理が終了し、答えは2。 123は3桁の数なので、手順2を施します。 この場合は12,3と1,23の二つの分け方があり、それぞれでかけざんをすると36,23となるので、 36が次の数として選ばれます。 Sample Input 2 2 999999 1000000 Output for the Sample Input 2 12 1
[ { "submission_id": "aoj_2424_9575336", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)\n#define rrep(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)\n#define ALL(v) (v).begin(), (v).end()\n#define UNIQUE(v) sort(ALL(v)...
aoj_2436_cpp
問題名 今 n 枚の数字が書かれたカードがあります。これらの一部または全部を適当に並べて数字を作ることを考えます。この時作られる数字を全て足した数を求めて下さい。 例えば、 1 と 2 があったら、作られる数字は 1, 2, 12, 21 の 4 つなので、全て足した数は 36 になります。並べた結果同じ数字が出来ても違う並べ方だとしたら別々に足します。たとえば、 1 というカードと 11 というカードがあったら並べて 111 になる並べ方が2通りありますがそれぞれ別のものとして足し合わせます。カードの中にリーディングゼロのカードはありませんし、リーディングゼロになる数字は認めません。答えを1,000,000,007 で割ったものを出力してください。 Input 入力は、以下の形で与えられます。 n a 1 a 2 ... a n 最初の 1 行にはカードの枚数を表す n （ 1 ≤ n ≤ 200 ）、次の n 行にはそれぞれのカードに書かれている数字 a i ( 0 ≤ a i < 10000 ) が書かれています。また複数のカードに同じ数字が書かれていることはありません。 Output 作ることの出来る全ての数字の合計を 1,000,000,007 で割ったものを 1 行に出力しなさい。 Sample Input 1 2 1 2 Output for the Sample Input 1 36 サンプルにあった例です。 Sample Input 2 2 1 11 Output for the Sample Input 2 234 作られる数字は 1 と 11 と、 111 が 2 通り作られるので全て足して 234 となります。 Sample Input 3 4 0 4 7 8 Output for the Sample Input 3 135299 04 や 078 といった並べ方は認められないことに注意してください。
[ { "submission_id": "aoj_2436_10561821", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\nconst long long mod = 1000000007;\n\nint dp[202][202][802];\n\nlong long solve(vector<string> S) {\n\tif (S.size() == 0) return 0;\n\tvector<int> digsum(6, 0);\n\tfor (int i = 0; i < S.size(); i++) {\n\t...
aoj_2432_cpp
Sports Days 2.0 会津大学附属小学校（会津大小）は日本有数の競技プログラマー養成校として有名である。 もちろん、運動会に参加しているときでさえアルゴリズムの修行を欠かせない。 競技プログラミング部部長のあなたはもちろんこの大会でも勝利したい。 今回はある競技に注目する。 ある競技とは会津大小で行われている伝統的な競技だ。 校庭にコーンが V 個置いてある。 コーンのいくつかのペアは白線で描かれた矢印で結ばれている。 矢印の先は片側だけについており、整数が併記されている。 同じコーンのペアがの複数の矢印に結ばれている場合もある。 競技者は任意にコーンを選び、移動開始する。 移動は競技者がいるコーンから矢印の上をその向きに移動し、次のコーンへ移る。 同じコーン、同じ矢印を何度も辿っても良い。 競技者はコーンからコーンへの移動後、さらに移動するか移動を終了をするかを選択することができる。 この競技の目的は矢印を辿ることにより、スコアをK以上にすることである。 スコアは矢印を辿る度に併記された整数値が加算されていく。 より少ない経由する矢印の本数でスコアを K 以上にした競技者が勝利となる。 矢印が同じ本数の場合はより高いスコアの競技者が勝利となる。 このルールで最適な動きを競技者が行った場合、何本の矢印を経由すべきか出力せよ。 また、経由した矢印の数が100本以下の場合、経由すべきコーンを順にすべて出力せよ。 最適な動きが複数存在する場合があるが、どの動きの結果を出力しても良い。 スコアを K 以上にする動きが存在しない場合は-1を出力せよ。 また、コーンにはすべて0から V-1 までの番号が振られており、 色はすべて緑色（意味深）である。 Input 入力は以下の形式で与えられる。 V E K v 11 v 12 c 1 ... v i1 v i2 c i ... v E1 v E2 c E ここで、 V はコーンの数 E は矢印の数 v i,1 は矢印 i の始点のコーン番号 v i2 は矢印 i の終点のコーン番号 c i は矢印に併記されている整数 である。 Constraints 入力は以下の条件を満たす。 入力はすべて整数 2≤V≤150 0≤E≤V×V 0<K≤10 6 0≤ v i1 , v i2 < V (0<i≤E) v i1 ≠ v i2 (0<i≤E) 0<c i ≤ 100 (0<i≤E) v i1 = v j1 かつ v i2 = v j2 (i ≠ j, 0<i,j≤E) となるような i, j が含まれる入力も存在する。 Output 出力は2行からなる。 1行目　最適な動きを行った場合の経由する矢印の本数で出力 2行目　経由すべきコーンの番号を経由する順番に空白区切りで出力 最適な動きが複数存在する場合があるが、どの動きの結果を出力しても良い。 経由すべき矢印の本数が100本を越える場合、2行目は出力してはいけない。 スコアを K 以上にする最適な動きが存在しない場合は-1を1行目に出力し、 2行目に何も出力してはいけない。 Sample Input 1 3 9 89 2 0 2 1 0 3 2 0 1 2 0 3 0 1 1 0 1 2 1 2 3 0 1 1 1 0 2 Output for the Sample Input 1 34 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 0 Sample Input 2 2 0 1 Output for the Sample Input 2 -1 Sample Input 3 7 8 4000 0 1 1 1 0 1 1 2 2 2 3 2 3 4 2 5 4 3 3 5 4 5 6 5 Output for the Sample Input 3 3991
[ { "submission_id": "aoj_2432_10848636", "code_snippet": "#include <bits/stdc++.h>\nusing namespace std;\n\nusing ll = long long int;\nusing ull = unsigned long long int;\nusing P = pair<int, int>;\nusing P3 = pair<int,P>;\nusing PP = pair<P, P>;\nconstexpr int INF32 = 1 << 30;\nconstexpr ll INF64 = 1LL << 6...
aoj_2435_cpp
問題名 Zero division checker 森下さんは困っていました... 姉原さんにプログラムを書いてもらったのですが、そのプログラムがクラッシュするのです。 姉原さんに書いてもらったのは、逆ポーランド記法の式を読んで、その計算結果を出力するプログラムで、クラッシュログによると、 0 で割り算をしてしまったのが原因のようです。これは、森下さんが間違った式を入力してしまったからかもしれませんし、もしかしたら、もしかしたら、姉原さんの書いたプログラムにバグがあるのかもしれません。 姉原さんの書いたプログラムを読んでみようと思いましたが、姉原さんのプログラムはアセンブリというよくわからないことばで書かれているようで、見ているだけで頭がガンガンしてきます。 そこで、森下さんはあなたに、式が間違っていないかどうか調べるプログラムを書いてもらうことにしました。式が間違っている、とは、その式に従って計算すると、 0 での割り算をしてしまう可能性のあることをいいます。 なお、姉原さんの書いたコードはとてもふるいコンピューターで動くもので、加減乗除は整数で行い、結果は 8 bit の符号なし整数として保存されます。 例えば、 255+1 は 0 になってしまうし、 3/2 は 1 になります。 あ、姉原さんにはないしょですよ。 (参考)逆ポーランド記法で表された式を計算する、擬似コード s = 空のスタック n = 式の要素数 for i in 1..n: if 式のi番目の要素が整数: sにその整数をプッシュする if 式のi番目の要素が変数: sにその変数の値をプッシュする if 式のi番目の要素が演算子: sから値をポップし、bとする sから値をポップし、aとする if 演算子が'+': r = (a + b) % 256 とする if 演算子が'-': r = (a - b + 256) % 256 とする if 演算子が'*': r = (a * b) % 256 とする if 演算子が'/': r = (a / b) % 256 とする sにrをプッシュする sから値をポップし、式の計算結果とする Input m name 1 lb 1 ub 1 ... name m lb m ub m n e 1 e 2 ... e n 0 ≤ m ≤ 100 0 ≤ lb i ≤ ub i ≤ 255 1 ≤ name i (1 ≤ i ≤ m) の長さ ≤ 20 1 ≤ n ≤ 100 m は変数の数、 name i , lb i , ub i はそれぞれ変数iの名前、下限、上限を表します。 n は式に含まれる要素の数を表し、 e i は式の i 番目の要素を表します。 各変数は式の中に高々1回しか現れません。 Output 式が間違っているときには error 、間違っていないときには correct と一行で出力してください。 Sample Input 1 1 a 1 10 3 10 a / Output for the Sample Input 1 correct Sample Input 2 2 a 1 10 b 1 10 5 1 a b - / Output for the Sample Input 2 error Sample Input 3 1 a 0 255 7 1 a 2 * 1 + / Output for the Sample Input 3 correct
[ { "submission_id": "aoj_2435_6708649", "code_snippet": "#include <algorithm>\n#include <bitset>\n#include <cassert>\n#include <chrono>\n#include <climits>\n#include <cmath>\n#include <cstddef>\n#include <cstdint>\n#include <cstdlib>\n#include <functional>\n#include <iomanip>\n#include <iostream>\n#include <...
aoj_2434_cpp
問題名 Audition アイドル---それは女の子達の永遠の憧れ。しかし、頂点に立てるのはほんの一握り。そんなサバイバルな世界に、あなたはアイドルプロデューサーとして足を踏み入れることになりました。そして、今日はあなたの担当アイドルを連れて大事なオーディションに挑むことになりました。 オーディションの決め手になるのはビジュアル、ダンス、ボーカルの 3 要素です。オーディション中には m 回のアピールタイムがあり、 1 回のアピールタイムごとに各アイドルはビジュアルアピール、ダンスアピール、ボーカルアピールのいずれかを行うことが出来ます。ビジュアルアピールを行うとそのアイドルのビジュアルポイントは彼女の持ってるビジュアル値だけ、ダンスアピールを行うとダンスポイントは彼女の持ってるダンス値だけ、ボーカルアピールを行うとボーカルポイントは彼女の持ってるボーカル値だけ上昇します。 m 回のアピールが終了した後、 N 人のアイドルのうちビジュアルポイントの高いほうから 3 人は 5 オーディションポイント、ダンスポイントの高いほうから 3 人は 3 オーディションポイント、ボーカルポイントの高いほうから 3 人は 2 オーディションポイントを獲得します。一方、ビジュアルポイントが最下位だとオーディションポイントは 1 点減点、ダンスポイントが最下位だとオーディションポイントは 1 点減点、ボーカルポイントが最下位だとオーディションポイントは 1 点減点となります。（オーディションポイントが1以下でもそこから 1 点減点）。 オーディションの始めに、各アイドルのビジュアルポイント、ダンスポイント、ボーカルポイントはそれぞれ 0 です。あなたはアイドル 1 のプロデューサーで、アピールタイムごとにどのアピールを行うか指示することが出来ます。アイドル 1 以外のアイドルはアピールタイムごとにランダムに等確率にどれかのアピールを行います（つまりそれぞれ 3 分の 1 の確率で行われる）。アイドル 1 のビジュアル、ダンス、ボーカルのポイントが他のアイドルと等しい場合、アイドル 1 は常に下位とします。アイドル 1 の獲得するオーディションポイントの期待値が最大になるように指示したときの期待値を求めて下さい。アイドルの運命は、あなたの指示にかかっています！ ちなみに、指示はオーディションが始まる前に全て行って、その後オーディション中の指示の変更は出来ないものとします。つまり、他のアイドルが、オーディションが始まってからのアピールでどのアピールをしかたを見てから、その場合においての期待値が最大となるような指示を出す、ということは出来ないものとします。 Input 入力は以下の形で与えられます。 n m vi 1 da 1 vo 1 vi 2 da 2 vo 2 ... vi n da n vo n 1行目にはオーディションに出場するアイドルの数 n ( 4 ≤ n ≤ 2000 ) と、このオーディションにおけるアピールタイムの数 m ( 1 ≤ m ≤ 2000 ) が書いてあります。次の n 行にはそれぞれアイドルiのビジュアル値 vi i 、ダンス値 da i 、ボーカル値 vo i ( 1 ≤ vi i , da i , vo i ≤ 10,000 )が書いてあります。 Output アイドル 1 の獲得するオーディションポイントの期待値の最大値を 1 行で出力しなさい。 Sample Input 1 4 1 1 1 1 1 1 1 1 1 1 1 1 1 Output for the Sample Input 1 2.777777777778 どのアピールを行っても、そのジャンルで 3 位以内に入れる確率は等しいですが、 3 位以内に入った時に貰えるオーディションポイントが最も多いビジュアルのアピールを行うのがもっとも期待値が良くなります。 Sample Input 2 4 10 1 1 1 10 10 10 10 10 10 10 10 10 Output for the Sample Input 2 -2.335340954780 非常に厳しいオーディションとなるでしょう。 Sample Input 3 9 9 13 5 19 19 21 37 15 1 7 7 11 15 21 23 25 33 29 19 13 19 11 21 5 15 7 13 1 Output for the Sample Input 3 4.678837855075
[ { "submission_id": "aoj_2434_9779526", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define rep(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)\n#define rrep(i, a, b) for (ll i = (ll)(b)-1; i >= (ll)(a); i--)\n#define ALL(v) (v).begin(), (v).end()\n#define UNIQUE(v) sort(ALL(v)), (v)...
aoj_2437_cpp
問題名 DNA 遺伝子は、 A , T , G , C からなる文字列です。 この世界の遺伝子は奇妙なことに、ある構文規則に従うことが知られています。 構文規則は、次のような形で与えられます。 非終端記号1: 記号1_1 記号1_2 ... 記号1_n1 非終端記号2: 記号2_1 記号2_2 ... 記号2_n2 ... 非終端記号m: 記号m_1 記号m_2 ... 記号m_nm 記号は非終端記号または終端記号のどちらかです。 非終端記号は小文字文字列で表され、終端記号は A , T , G , C のうちのいくつかの文字が、" [ "と" ] "に囲まれた文字列で表されます。 構文規則の例は次のようになります。 dna: a a b b a: [AT] b: [GC] " 非終端記号i: 記号i_1 記号i_2 ... 記号i_ni " を非終端記号 i のルールと呼び、ルールは、構文規則に現れる各非終端記号に対して、ちょうど 1 つづつ存在します。 文字列 s が非終端記号 i に「 マッチする 」とは、 s = s 1 + s 2 + ... + s ni となるような s の部分文字列 {s j } が存在し、 s j ( 1 ≤ j ≤ n i )がルール内の記号 j にマッチすることをいいます。 文字列 s が終端記号に「 マッチする 」とは、文字列が 1 文字からなり、その文字が終端記号を表す文字列に含まれることをいいます。 文字列が構文規則に従うとは、非終端記号 1 にその文字列がマッチすることをいいます。 ルール i は、記号のうちに、非終端記号 j ( j ≤ i ) を含みません。 構文規則と、4つの整数 Na , Nt , Ng , Nc が与えられます。 構文規則に従い、A をちょうど Na 個、T をちょうど Nt 個、G をちょうど Ng 個、C をちょうど Nc 個含むような遺伝子の総数を 1,000,000,007 で割った余りを求めなさい。 Input Na Nt Ng Nc m 非終端記号1: 記号 1 1 記号 1 2 ... 記号 1 n1 非終端記号2: 記号 2 1 記号 2 2 ... 記号 2 n2 ... 非終端記号 m : 記号 m 1 記号 m 2 ... 記号 m nm 0 ≤ Na, Nt, Ng, Nc ≤ 50 1 ≤ m ≤ 50 1 ≤ ni ≤ 10 1 ≤ 記号を表す文字列の長さ ≤ 20 (※記号にマッチする文字列の長さではないことに注意) Output 総数を 1,000,000,007 で割った余り Sample Input 1 1 0 1 0 3 dna: a b a: [AT] b: [GC] Output for the Sample Input 1 1 "AG"の一つです。 Sample Input 2 1 1 1 2 1 k: [ATG] [ATG] [ATG] [C] [C] Output for the Sample Input 2 6 "ATGCC", "AGTCC", "TAGCC", "TGACC", "GATCC", "GTACC"の6つです。 Sample Input 3 3 1 1 1 3 inv: at b b b at: [ATG] b b: [C] Output for the Sample Input 3 0
[ { "submission_id": "aoj_2437_9582362", "code_snippet": "#include <bits/stdc++.h>\n\nusing namespace std;\n\n#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)\n#define rrep(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)\n#define ALL(v) (v).begin(), (v).end()\n#define UNIQUE(v) sort(ALL(v)...
aoj_2441_cpp
FizzBuzz FizzBuzzとは、1以上の整数を順に、以下のルールに従って発言していくゲームである。 3で割り切れる時には「Fizz」 5で割り切れる時には「Buzz」 3と5の両方で割り切れる時には「FizzBuzz」 それ以外の時はその数字 ゲームの進行状況の例を以下に示す。 1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, … 得られた発言を1つの文字列に結合し得られた文字列をFizzBuzz Stringと呼ぶ。インデックスsが与えられるので、FizzBuzz Stringのs文字目から20文字を出力せよ。但し、インデックスは1から始まるものとし、得られた文字列の長さは十分に大きい（s+20以上）としてよい。 Input 入力は以下の形式で与えられる s Constraints s は整数である 1 ≤ s ≤ 10 18 Output FizzBuzz Stringのs文字目から20文字を1行に出力せよ Sample Input 1 1 Output for the Sample Input 1 12Fizz4BuzzFizz78Fiz Sample Input 2 20 Output for the Sample Input 2 zzBuzz11Fizz1314Fizz Sample Input 3 10000000000 Output for the Sample Input 3 93FizzBuzz1418650796
[ { "submission_id": "aoj_2441_2971948", "code_snippet": "#include <iostream>\n#include <vector>\n#include <string>\n#include <cstring>\n#include <sstream>\nusing namespace std;\n\n// calc digit-dp\n// dp[(桁)][(num of leading-zero)][smaller][15 で割ったあまり] :＝ 個数\nlong long dp[21][21][3][16];\nlong long calc(long...