├── 11723-Numbering Roads.cpp ├── 11875-Brick Game.cpp ├── 10302-Summation of Polynomials.cpp ├── 10212-The Last Non-zero Digit.cpp ├── 10276-Hanoi Tower Troubles Again!.cpp ├── 10469-To Carry or not to Carry.cpp ├── 10346-Peter's Smokes.cpp ├── 11407-Squares.cpp ├── 147-Dollars.cpp ├── 494-Kindergarten Counting Game.java ├── 11849-CD.cpp ├── 10815-Andy's First Dictionary.cpp ├── 12592-Slogan Learning of Princess.cpp ├── 10509-R U Kidding Mr. Feynman?.cpp ├── 10684-The jackpot.cpp ├── 1260-Sales.cpp ├── 11078-Open Credit System.cpp ├── 11900-Boiled Eggs.cpp ├── 10656-Maximum Sum (II).cpp ├── 12210-A Match Making Problem.cpp ├── 11369-Shopaholic.cpp ├── 10714-Ants.cpp ├── 11417-GCD.cpp ├── 11703-sqrt log sin.cpp ├── 1230-MODEX.java ├── 374-Big Mod.cpp ├── 10340-All in All.cpp ├── 847-A Multiplication Game.cpp ├── 11137-Ingenuous Cubrency.cpp ├── 325-Identifying Legal Pascal Real Constants.java ├── 369-Combinations.cpp ├── 10282-Babelfish.cpp ├── 10041-Vito's Family.cpp ├── 12461-Airplane.cpp ├── 12405-Scarecrow.cpp ├── 146-ID Codes.cpp ├── 623-500!.java ├── 10176 - Ocean Deep!-Make it shallow!!.cpp ├── 11879-Multiple of 17.java ├── 10365-Blocks.cpp ├── 674-Coin Change.cpp ├── 10295-Hay Points.cpp ├── 10878-Decode the tape.cpp ├── 11054-Wine trading in Gergovia.cpp ├── 11136-Hoax or what.cpp ├── 10491-Cows and Cars.cpp ├── 10943-How do you add?.cpp ├── 350-Pseudo-Random Numbers.cpp ├── 10954-Add All.cpp ├── 10226-Hardwood Species.cpp ├── 10334-Ray Through Glasses.java ├── 357-Let Me Count The Ways.cpp ├── 679-Dropping Balls.cpp ├── 10104-Euclid Problem.cpp ├── 10551-Basic Remains.java ├── 11254-Consecutive Integers.cpp ├── 1203-Argus.cpp ├── 12049-Just Prune The List.cpp ├── 902-Password Search.cpp ├── 10523-Very Easy !!!.java ├── 11420-Chest of Drawers.cpp ├── 256-Quirksome Squares.cpp ├── 11231-Black and white painting.cpp ├── 11342-Three-square.cpp ├── 12583-Memory Overflow.cpp ├── 231-Testing the CATCHER.cpp ├── 10763-Foreign Exchange.cpp ├── 11621-Small Factors.cpp ├── 12488-Start Grid.cpp ├── 460-Overlapping Rectangles.cpp ├── 484-The Department of Redundancy Department.cpp ├── 10405-Longest Common Subsequence.cpp ├── 10699-Count the factors.cpp ├── 10678-The Grazing Cow.cpp ├── 11572-Unique Snowflakes.cpp ├── 11991-Easy Problem from Rujia Liu.cpp ├── 11062-Andy's Second Dictionary.cpp ├── 11286-Conformity.cpp ├── 11827-Maximum GCD.cpp ├── 1196-Tiling Up Blocks.cpp ├── 10063-Knuth's Permutation.cpp ├── 389-Basically Speaking.java ├── 729-The Hamming Distance Problem.cpp ├── 417-Word Index.cpp ├── 10721-Bar Codes.cpp ├── 10338-Mischievous Children.cpp ├── 10446-The Marriage Interview :-).cpp ├── 12485-Perfect Choir.cpp ├── 10252-Common Permutation.cpp ├── 10814-Simplifying Fractions.java ├── 10056-What is the Probability ?.cpp ├── 10843-Anne's game.cpp ├── 10394-Twin Primes.cpp ├── 10790-How Many Points of Intersection?.cpp ├── 471-Magic Numbers.cpp ├── 10812-Beat the Spread!.cpp ├── 11350-Stern-Brocot Tree.cpp ├── 11917-Do Your Own Homework.cpp ├── 10407-Simple division.cpp ├── 11389-The Bus Driver Problem.cpp ├── 1225-Digit Counting.cpp ├── 10192-Vacation.cpp ├── 10976-Fractions Again?!.cpp ├── 10774-Repeated Josephus.cpp ├── 10912-Simple Minded Hashing.cpp ├── 11103-WFF 'N PROOF.cpp ├── 11517-Exact Change.cpp ├── 11264-Coin Collector.cpp ├── 441-Lotto.cpp ├── 278-Chess.cpp ├── 412-Pi.cpp ├── 10928-My Dear Neighbours.cpp ├── 11242-Tour de France.cpp ├── 12455-Bars.cpp ├── 10689-Yet another Number Sequence.cpp ├── 11285-Exchange Rates.cpp ├── 498-Polly the Polynomial.cpp ├── 957-Popes.cpp ├── 10925-Krakovia.java ├── 11565-Simple Equations.cpp ├── 1207-AGTC.cpp ├── 594-One Little, Two Little, Three Little Endians.cpp ├── 11634-Generate random numbers.cpp ├── 1261-String Popping.cpp ├── 386-Perfect Cubes.cpp ├── 1213-Sum of Different Primes.cpp ├── 10583-Ubiquitous Religions.cpp ├── 11151-Longest Palindrome.cpp ├── 347-Run.cpp ├── 562-Dividing coins.cpp ├── 10003-Cutting Sticks.cpp ├── 10460-Find the Permuted String.cpp ├── 10905-Children's Game.cpp ├── 10074-Take the Land.cpp ├── 10152-ShellSort.cpp ├── 10664-Luggage.cpp ├── 10036-Divisibility.cpp ├── 10154-Weights and Measures.cpp ├── 108-Maximum Sum.cpp ├── 11628-Another lottery.cpp ├── 111-History Grading.cpp ├── 11463-Commandos.cpp ├── 10673-Play with Floor and Ceil.cpp ├── 11933-Splitting Numbers.cpp ├── 12032-The Monkey and the Oiled Bamboo.cpp ├── 12541-Birthdates.cpp ├── 713-Adding Reversed Numbers.java ├── 983-Localized Summing for Blurring.cpp ├── 11341-Term Strategy.cpp ├── 616-Coconuts, Revisited.cpp ├── 10066-The Twin Towers.cpp ├── 1237-Expert Enough?.cpp ├── 10125-Sumsets.cpp ├── 11218-KTV.cpp ├── 11961-DNA.cpp ├── 10910-Marks Distribution.cpp ├── 11100-The Trip, 2007.cpp ├── 624-CD.cpp ├── 10081-Tight Words.cpp ├── 11311-Exclusively Edible.cpp ├── 10858-Unique Factorization.cpp ├── 11057-Exact Sum.cpp ├── 11881-Internal Rate of Return.cpp ├── 476-Points in Figures: Rectangles.cpp ├── 10730-Antiarithmetic?.cpp ├── 10892-LCM Cardinality.cpp ├── 459-Graph Connectivity.cpp ├── 10077-The Stern-Brocot Number System.cpp ├── 686-Goldbach's Conjecture (II).cpp ├── 11292-Dragon of Loowater.cpp ├── 514-Rails.cpp ├── 10567-Helping Fill Bates.cpp ├── 558-Wormholes.cpp ├── 10635-Prince and Princess.cpp ├── 10235-Simply Emirp.java ├── 10344-23 out of 5.cpp ├── 1062-Containers.cpp ├── 10617-Again Palindrome.cpp ├── 11824-A Minimum Land Price.cpp ├── 10227-Forest.cpp ├── 11753-Creating Palindrome.cpp ├── 12346-Water Gate Management.cpp ├── 10128-Queue.cpp ├── 11053-Flavius Josephus Reloaded.cpp ├── 11173-Grey Codes.cpp ├── 10706-Number Sequence.cpp ├── 10325-The Lottery.cpp ├── 10341-Solve It.cpp ├── 11959-Dice.cpp ├── 10608-Friends.cpp ├── 11396-Claw Decomposition.cpp ├── 378-Intersecting Lines.cpp ├── 10738-Riemann vs Mertens.cpp ├── 11258-String Partition.cpp ├── 10718-Bit Mask.cpp ├── 10298-Power Strings.cpp ├── 10520-Determine it.cpp ├── 11157-Dynamic Frog.cpp ├── 154-Recycling.cpp ├── 10935-Throwing cards away I.cpp ├── 11059-Maximum Product.cpp ├── 11133-Eigensequence.cpp ├── 11432-Busy Programmer.cpp ├── 11690-Money Matters.cpp ├── 10865-Brownie Points.cpp ├── 10742-The New Rule in Euphomia.cpp ├── 10785-The Mad Numerologist.cpp ├── 11629-Ballot evaluation.cpp ├── 331-Mapping the Swaps.cpp ├── 10680-LCM.cpp ├── 12348-Fun Coloring.cpp ├── 12515-Movie Police.cpp ├── 1362-Exploring Pyramids.cpp ├── 507-Jill Rides Again.cpp ├── 543-Goldbach's Conjecture.cpp ├── 10685-Nature.cpp ├── 11348-Exhibition.cpp ├── 11953-Battleships.cpp ├── 725-Division.cpp ├── 10305-Ordering Tasks.cpp ├── 10534-Wavio Sequence.cpp ├── 821-Page Hopping.cpp ├── 102-Ecological Bin Packing.cpp ├── 10895-Matrix Transpose.cpp ├── 11777-Automate the Grades.cpp ├── 12321-Gas Stations.cpp ├── 793-Network Connections.cpp ├── 855-Lunch in Grid City.cpp ├── 352-The Seasonal War.cpp ├── 11588-Image Coding.cpp ├── 260-Il Gioco dell'X.cpp ├── 410-Station Balance.cpp ├── 473-Raucous Rockers.cpp ├── 10218-Let's Dance !!!.cpp ├── 10029-Edit Step Ladders.cpp ├── 11003-Boxes.cpp ├── 11988-Broken Keyboard (a.k.a. Beiju Text).cpp ├── 10130-SuperSale.cpp ├── 11321-Sort! Sort!! and Sort!!!.cpp ├── 11548-Blackboard Bonanza.cpp ├── 10827-Maximum sum on a torus.cpp ├── 11205-The broken pedometer.cpp ├── 882-The Mailbox Manufacturers Problem.cpp ├── 10102-The path in the colored field.cpp ├── 10337-Flight Planner.cpp ├── 1197-The Suspects.cpp ├── 1241-Jollybee Tournament.cpp ├── 188-Perfect Hash.cpp ├── 10474 - Where is the Marble?.cpp ├── 10487-Closest Sums.cpp ├── 501-Black Box.cpp ├── 11413-Fill the Containers.cpp └── 12324-Philip J. Fry Problem.cpp /11723-Numbering Roads.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int tc=1; 7 | double r,n; 8 | while(scanf("%lld %lld",&r,&n),(r+n)!=0){ 9 | int needed = ceil(r/n)-1; 10 | printf("Case %d: ",tc++); 11 | if(needed<=26) printf("%d\n",needed); 12 | else printf("impossible\n"); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /11875-Brick Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int t,n,v,tc=1; 7 | scanf("%d",&t); 8 | while(t--){ 9 | scanf("%d",&n); 10 | for(int i=0;i 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | 9 | int main() { 10 | ll n; 11 | while(cin >> n) { 12 | ll res = n*n*(n+1)*(n+1)/4; 13 | cout << res << "\n"; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /10212-The Last Non-zero Digit.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n,m; 8 | while(scanf("%d %d",&n,&m) != EOF) { 9 | long long res = 1; 10 | for(int i=n;i>n-m;i--) { 11 | res *= i; 12 | while(res%10 == 0) res/=10; 13 | res %= 1000000000; 14 | } 15 | printf("%d\n",res%10); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /10276-Hanoi Tower Troubles Again!.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // O(1), mathematical proof by induction of 1,2,3... 5 | // another approach is greedy simulation 6 | // always pick existing leftmost peg 7 | 8 | int main() 9 | { 10 | int t; 11 | int n; 12 | cin >> t; 13 | while(t--){ 14 | cin >> n; 15 | cout << (n+1)*(n+1)/2-1 << endl; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /10469-To Carry or not to Carry.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | typedef long long ll; 7 | 8 | void solve() { 9 | ll a, b; 10 | while(cin >> a) { 11 | cin >> b; 12 | cout << (a^b) << "\n"; 13 | } 14 | } 15 | 16 | int main() { 17 | solve(); 18 | } 19 | -------------------------------------------------------------------------------- /10346-Peter's Smokes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n,k; 7 | while(scanf("%d %d",&n,&k) != EOF){ 8 | int sum = n; 9 | int butts = n; 10 | while(butts >= k){ 11 | int newCiga = butts/k; 12 | butts %= k; 13 | sum += newCiga; 14 | butts += newCiga; 15 | } 16 | printf("%d\n",sum); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /11407-Squares.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | vector dp(10001,1e7); 7 | dp[0] = 0; 8 | for(int i=1;i*i<=10000;i++){ 9 | int num = i*i; 10 | for(int j=num;j<=10000;j++) 11 | dp[j] = min(dp[j],dp[j-num]+1); 12 | } 13 | int t,v; 14 | cin >> t; 15 | while(t--){ 16 | scanf("%d",&v); 17 | printf("%d\n",dp[v]); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /147-Dollars.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int coins[] = {5,10,20,50,100,200,500,1000,2000,5000,10000}; 7 | long long dp[30001] = {}; 8 | dp[0] = 1; 9 | for(auto& coin : coins) 10 | for(int i=coin;i<30001;i++) 11 | dp[i] += dp[i-coin]; 12 | double in; 13 | while(scanf("%lf",&in),in) 14 | printf("%6.2f%17lld\n",in,dp[(int)round(in*100)]); 15 | } 16 | -------------------------------------------------------------------------------- /494-Kindergarten Counting Game.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class Main { 3 | public static void main(String args[]) { 4 | String in; 5 | Scanner sc = new Scanner(System.in); 6 | 7 | while(sc.hasNext()){ 8 | in = sc.nextLine(); 9 | in = in.replaceAll("(^[^a-zA-Z]+)|([^a-zA-Z]+$)", ""); 10 | System.out.println(in.split("[^a-zA-Z]+").length); 11 | } 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /11849-CD.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,m,v; 6 | while(scanf("%d %d",&n,&m),n || m){ 7 | unordered_set s; 8 | int res = 0; 9 | while(n--){ 10 | cin>>v; 11 | s.insert(v); 12 | } 13 | while(m--){ 14 | cin>>v; 15 | if(s.count(v)) res++; 16 | } 17 | cout << res << endl; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /10815-Andy's First Dictionary.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string in; 6 | set distinct; 7 | while(getline(cin,in)){ 8 | in = regex_replace(in,regex("[^a-zA-Z]")," "); 9 | transform(in.begin(),in.end(),in.begin(),::tolower); 10 | istringstream iss(in); 11 | while(iss >> in) distinct.insert(in); 12 | } 13 | for(auto& s : distinct) cout << s << endl; 14 | } 15 | -------------------------------------------------------------------------------- /12592-Slogan Learning of Princess.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,q; 6 | string k,v; 7 | unordered_map slogan; 8 | scanf("%d\n",&n); 9 | while(n--){ 10 | getline(cin,k); 11 | getline(cin,v); 12 | slogan[k] = v; 13 | } 14 | scanf("%d\n",&q); 15 | while(q--){ 16 | getline(cin,k); 17 | cout << slogan[k] << endl; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /10509-R U Kidding Mr. Feynman?.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(4); cin.tie(nullptr); return 0; } 4 | int __fastio = fastio(); 5 | 6 | int main(){ 7 | double n; 8 | while(cin >> n, n != 0) { 9 | double a = floor(cbrt(n)); // largest a^3 <= n 10 | double dx = (n - pow(a,3)) / 3 / pow(a,2); 11 | cout << dx+a << "\n"; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /10684-The jackpot.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,v; 7 | while(scanf("%d",&n),n){ 8 | int cur = 0,best = 0; 9 | for(int i=0;i> v; 11 | cur = max(0,cur+v); 12 | best = max(best,cur); 13 | } 14 | if(best) printf("The maximum winning streak is %d.\n",best); 15 | else printf("Losing streak.\n"); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /1260-Sales.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,v; 6 | cin >> t; 7 | while(t--){ 8 | cin >> n; 9 | int sum = 0; 10 | multiset prev; 11 | while(n--){ 12 | cin >> v; 13 | auto upper = prev.upper_bound(v); 14 | sum += distance(prev.begin(),upper); 15 | prev.insert(v); 16 | } 17 | cout << sum << endl; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /11078-Open Credit System.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,v; 6 | cin >> t; 7 | while(t--){ 8 | cin >> n; 9 | int maxScore; 10 | int maxDiff = INT_MIN; 11 | cin >> maxScore; 12 | for(int i=1;i> v; 14 | maxDiff = max(maxDiff, maxScore-v); 15 | maxScore = max(maxScore,v); 16 | } 17 | cout << maxDiff << endl; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /11900-Boiled Eggs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,p,q,v,tc=1; 6 | cin >> t; 7 | while(t--){ 8 | cin >> n >> p >> q; 9 | int res = 0, totalWeight=0; 10 | for(int i=0;i> v; 12 | if(totalWeight+v <= q && res 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n,v; 8 | while(cin >> n, n){ 9 | bool notEmpty = false; 10 | for(int i=0;i> v; 12 | if(v){ 13 | if(notEmpty) printf(" "); 14 | notEmpty = true; 15 | printf("%d",v); 16 | } 17 | } 18 | if(!notEmpty) printf("0"); 19 | printf("\n"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /12210-A Match Making Problem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int b,s,v,tc=1; 6 | while(scanf("%d %d",&b,&s),b||s){ 7 | int youngestBachelor = INT_MAX; 8 | for(int i=0;i> v, youngestBachelor = min(youngestBachelor,v); 10 | for(int i=0;i> v; 11 | printf("Case %d: ",tc++); 12 | if(b<=s) printf("0\n"); 13 | else printf("%d %d\n",b-s,youngestBachelor); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /11369-Shopaholic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,n,v; 8 | cin >> t; 9 | while(t--){ 10 | cin >> n; 11 | vector prices; 12 | for(int i=0;i> v; 14 | prices.push_back(v); 15 | } 16 | sort(prices.begin(),prices.end(),greater()); 17 | int res = 0; 18 | for(int i=2;i 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,len,n,v; 8 | cin >> t; 9 | while(t--){ 10 | cin >> len >> n; 11 | int least = 0, most = 0; 12 | for(int i=0;i> v; 14 | int more = max(len-v,v); 15 | int less = min(len-v,v); 16 | least = max(less,least); 17 | most = max(more,most); 18 | } 19 | printf("%d %d\n",least,most); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /11417-GCD.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int ans[501] = {}; 5 | int gcd[501][501] = {}; 6 | 7 | int compute(int x,int y){ 8 | return x == 0 ? y : compute(y%x,x); 9 | } 10 | 11 | int main() { 12 | for(int i=1;i<501;i++){ 13 | for(int j=i+1;j<501;j++){ 14 | gcd[i][j] = gcd[i][j-1] + compute(i,j); 15 | ans[j] += gcd[i][j]; 16 | } 17 | } 18 | int n; 19 | while(scanf("%d",&n),n){ 20 | printf("%d\n",ans[n]); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /11703-sqrt log sin.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int memo[1000001] = {}; 5 | int solve(int n){ 6 | if(memo[n] != -1) return memo[n]; 7 | int res = solve(floor(n-sqrt(n))); 8 | res += solve(floor(log(n))); 9 | res += solve(floor(n*sin(n)*sin(n))); 10 | return memo[n] = res%1000000; 11 | } 12 | 13 | int main() 14 | { 15 | memset(memo,-1,sizeof memo); 16 | memo[0] = 1; 17 | int n; 18 | while(scanf("%d",&n),n!=-1) 19 | printf("%d\n",solve(n)); 20 | } 21 | -------------------------------------------------------------------------------- /1230-MODEX.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | int t= sc.nextInt(); 8 | while(t-- > 0){ 9 | BigInteger x = sc.nextBigInteger(); 10 | BigInteger y = sc.nextBigInteger(); 11 | BigInteger n = sc.nextBigInteger(); 12 | // (x^y) % n 13 | System.out.println(x.modPow(y,n)); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /374-Big Mod.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int solve(int b, int p, int m) { 6 | if (p==0) return 1; 7 | 8 | int half = solve(b,p/2,m)%m; 9 | int res = (half*half)%m; 10 | if(p%2==1) 11 | return (res*b)%m; 12 | return res; 13 | } 14 | 15 | int main() 16 | { 17 | // compute b^p mod m 18 | int b,p,m; 19 | while(scanf("%d",&b) != EOF) { 20 | scanf("%d %d",&p,&m); 21 | b%=m; 22 | printf("%d\n",solve(b,p,m)%m); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /10340-All in All.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool isSubseq(const string& a, const string& b){ 6 | if(a.size() > b.size()) return false; 7 | int i=0; 8 | for(int j=0;j> pattern){ 18 | cin >> str; 19 | cout << (isSubseq(pattern,str) ? "Yes" : "No") << endl; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /847-A Multiplication Game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n; 8 | while(scanf("%d",&n) != EOF){ 9 | bool p1Turn = true; 10 | for(int cur=1; cur 2 | using namespace std; 3 | 4 | vector cubes; 5 | 6 | void genCubes(){ 7 | for(int i=1;i<=21;i++){ 8 | cubes.push_back(i*i*i); 9 | } 10 | } 11 | 12 | int main() 13 | { 14 | genCubes(); 15 | vector dp(10001); 16 | dp[0] = 1; 17 | for(auto& cube : cubes) 18 | for(int i=cube;i<10001;i++) 19 | dp[i] += dp[i-cube]; 20 | int n; 21 | while(scanf("%d",&n) != EOF) 22 | printf("%lld\n",dp[n]); 23 | } 24 | -------------------------------------------------------------------------------- /325-Identifying Legal Pascal Real Constants.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | public class Main { 3 | public static void main(String args[]) { 4 | String in; 5 | Scanner sc = new Scanner(System.in); 6 | 7 | while(!(in = sc.next()).equals("*")){ 8 | if(in.matches("[-+]?\\d+(\\.\\d+([eE][-+]?\\d+)?|[eE][-+]?\\d+)")) 9 | System.out.println(in + " is legal."); 10 | else 11 | System.out.println(in + " is illegal."); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /369-Combinations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | constexpr int N = 101; 5 | ll dp[N][N]; 6 | void solve() { 7 | for(int i=0;i> n >> m, (n+m)) { 15 | cout << n << " things taken " << m << " at a time is " << dp[n][m] << " exactly.\n"; 16 | } 17 | } 18 | 19 | int main() { 20 | int t=1; 21 | while(t--) { 22 | solve(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /10282-Babelfish.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | int main() 9 | { 10 | string in1,in2; 11 | unordered_map trans; 12 | while(getline(cin,in1), !in1.empty()){ 13 | istringstream iss(in1); 14 | iss >> in1 >> in2; 15 | trans[in2] = in1; 16 | } 17 | while(cin >> in1){ 18 | if(trans.count(in1)) cout << trans[in1] << endl; 19 | else cout << "eh" << endl; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /10041-Vito's Family.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,v; 6 | cin >> t; 7 | while(t--){ 8 | cin >> n; 9 | vector neigh; 10 | int sum = 0; 11 | while(n--){ 12 | cin >> v; 13 | neigh.push_back(v); 14 | } 15 | sort(neigh.begin(),neigh.end()); 16 | int median = neigh[neigh.size()/2]; 17 | 18 | for(auto& v : neigh) sum += abs(v-median); 19 | 20 | cout << sum << endl; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /12461-Airplane.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(6); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | void solve() { 8 | int n; 9 | while(cin >> n, n) { 10 | // F[1] = 1 11 | // F[2] = 0.5, 50% sit on his own seat 12 | // F[3] = 1/3*F[2] + 1/3 = 1/6 + 2/3 = 0.5 13 | // F[4] = 2/4*F[3] + 1/4 = 0.5 14 | // ..., all 0.5 when n > 1 15 | cout << "1/2\n"; 16 | } 17 | } 18 | 19 | int main() { 20 | solve(); 21 | } 22 | -------------------------------------------------------------------------------- /12405-Scarecrow.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,tc=1; 6 | char c; 7 | cin >> t; 8 | while(t--){ 9 | cin >> n; 10 | int furthest = -1; 11 | int res = 0; 12 | for(int i=0;i> c; 14 | if(c == '.' && furthest 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main(){ 18 | string in; 19 | while(cin >> in, in != "#"){ 20 | cout << (next_permutation(in.begin(),in.end()) ? in : "No Successor" )<< endl; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /623-500!.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(sc.hasNext()){ 8 | int n = sc.nextInt(); 9 | System.out.println(n+"!"); 10 | BigInteger res = BigInteger.ONE; 11 | for(int i=2;i<=n;i++){ 12 | res = res.multiply(BigInteger.valueOf(i)); 13 | } 14 | System.out.println(res); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /10176 - Ocean Deep!-Make it shallow!!.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // modulo works for binary conversion if we only need partial result 6 | int main() 7 | { 8 | char c; 9 | long long res = 0; 10 | while(scanf("%c",&c) != EOF) { 11 | if(c == '1' || c == '0') { 12 | res <<= 1; 13 | if(c == '1') res += 1; 14 | res %= 131071; 15 | } else if (c == '#') { 16 | cout << (res == 0 ? "YES" : "NO") << endl; 17 | res = 0; 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /11879-Multiple of 17.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(true){ 8 | BigInteger n = sc.nextBigInteger(); 9 | if(n.compareTo(BigInteger.ZERO) == 0) break; 10 | if(n.mod(BigInteger.valueOf(17)).compareTo(BigInteger.ZERO) == 0) 11 | System.out.println("1"); 12 | else 13 | System.out.println("0"); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /10365-Blocks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,n; 7 | cin >> t; 8 | while(t--){ 9 | cin >> n; 10 | int res = INT_MAX; 11 | // find any square surface 12 | for(int l=1;l<=sqrt(n);l++) 13 | for(int h=l;h<=sqrt(n);h++) 14 | // check if exist width for such n,l,h 15 | if((n%h) == 0 && ((n/h)%l) == 0){ 16 | int w = (n/h)/l; 17 | res = min(res, 2*l*w+2*h*w+2*l*h); 18 | } 19 | cout << res << endl; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /674-Coin Change.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n,v; 4 | vector coins = {1,5,10,25,50}; 5 | int memo[6][7500]; 6 | 7 | int ccWays(int idx,int remain){ 8 | if(remain == 0) return 1; 9 | if(remain < 0 || idx == 5) return 0; 10 | if(memo[idx][remain] != -1) return memo[idx][remain]; 11 | return memo[idx][remain] = ccWays(idx+1,remain) + ccWays(idx,remain-coins[idx]); 12 | } 13 | 14 | int main() 15 | { 16 | memset(memo,-1,sizeof(memo)); 17 | while(scanf("%d",&v) != EOF) 18 | printf("%d\n",ccWays(0,v)); 19 | } 20 | -------------------------------------------------------------------------------- /10295-Hay Points.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | int main() 9 | { 10 | int a,b; 11 | string in; 12 | int v; 13 | scanf("%d %d",&a,&b); 14 | unordered_map cost; 15 | while(a--){ 16 | cin >> in >> v; 17 | cost[in] = v; 18 | } 19 | while(b--){ 20 | int total = 0; 21 | while(cin >> in , in != "."){ 22 | total += cost[in]; 23 | } 24 | cout << total << endl; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /10878-Decode the tape.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | string in; 8 | getline(cin,in); 9 | string res = ""; 10 | while(getline(cin,in), in != "___________"){ 11 | in.erase(remove(in.begin(),in.end(),'|'),in.end()); 12 | in.erase(remove(in.begin(),in.end(),'.'),in.end()); 13 | int ascii = 0; 14 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,v; 7 | while(scanf("%d",&n),n){ 8 | long long cur = 0, res = 0; 9 | for(int i=0;i> v; 11 | cur += v; 12 | // positive indicate I want wine to be moved here 13 | // negative, wines have to be shifted from here 14 | // so either way, add them as part of result 15 | res += abs(cur); 16 | } 17 | printf("%lld\n",res); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /11136-Hoax or what.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,b,v; 6 | while(cin >> n, n){ 7 | long long cost = 0; 8 | multiset rb; 9 | for(int i=0;i> b; 11 | while(b--){ 12 | cin >> v; 13 | rb.insert(v); 14 | } 15 | cost += *(--rb.end()) - *(rb.begin()); 16 | rb.erase(prev(rb.end())); 17 | rb.erase(rb.begin()); 18 | } 19 | cout << cost << endl; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /10491-Cows and Cars.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | // probability of cars: 6 | // choose car then car = (cars-1)/(total-show-1) 7 | // choose cow then car = car/(total-show-1) 8 | int main() { 9 | int cows,cars,show; 10 | while(scanf("%d %d %d",&cows,&cars,&show) != EOF) { 11 | int total = cars+cows; 12 | double carFirst = (double)(cars)/total*(double)(cars-1)/(total-show-1); 13 | double cowFirst = (double)(cows)/total*(double)(cars)/(total-show-1); 14 | printf("%.5f\n",carFirst+cowFirst); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /10943-How do you add?.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int dp[101][101] = {}; 7 | dp[0][0] = 1; 8 | // dp[n][k] = sum of dp[i][k-1] for i=0 to n 9 | // for each k 10 | for(int i=1;i<101;i++){ 11 | // for each number n 12 | int sum = 0; 13 | for(int j=0;j<101;j++){ 14 | sum = (sum+dp[j][i-1])%1000000; 15 | dp[j][i] = sum; 16 | } 17 | } 18 | int n,k; 19 | while(scanf("%d %d",&n,&k),(n+k) != 0){ 20 | printf("%d\n",dp[n][k]); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /350-Pseudo-Random Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | int z,i,m,l; 5 | 6 | int main() 7 | { 8 | int tc=1; 9 | while(scanf("%d %d %d %d",&z,&i,&m,&l),(z+i+m+l)) { 10 | int slow = l, fast = l; 11 | auto f = [](int x) { 12 | return (z*x+i)%m; 13 | }; 14 | int res = 0; 15 | while(true) { 16 | slow = f(slow); 17 | fast = f(f(fast)); 18 | res++; 19 | if(fast == slow) break; 20 | } 21 | printf("Case %d: %d\n",tc++,res); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10954-Add All.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() 7 | { 8 | int n,v; 9 | while(cin >> n, n) { 10 | priority_queue,greater> pq; 11 | while(n--){ 12 | cin >> v; 13 | pq.push(v); 14 | } 15 | int res = 0; 16 | while(pq.size() > 1) { 17 | int sum = pq.top(); pq.pop(); 18 | sum += pq.top(); pq.pop(); 19 | res += sum; 20 | pq.push(sum); 21 | } 22 | cout << res << endl; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /10226-Hardwood Species.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | int t; 10 | string in; 11 | scanf("%d\n\n",&t); 12 | while(t--){ 13 | int total = 0; 14 | map cntMap; 15 | while(getline(cin,in), !in.empty()){ 16 | total++; 17 | cntMap[in]++; 18 | } 19 | for(auto& p : cntMap) 20 | cout << p.first << " " << setprecision(4) << fixed << p.second*100.0/total << endl; 21 | if(t) cout << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10334-Ray Through Glasses.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | BigInteger seq[] = new BigInteger[1001]; 8 | seq[0] = BigInteger.valueOf(1); 9 | seq[1] = BigInteger.valueOf(2); 10 | for(int i=2;i<1001;i++) 11 | seq[i] = seq[i-1].add(seq[i-2]); 12 | 13 | while(sc.hasNext()){ 14 | int n = sc.nextInt(); 15 | System.out.println(seq[n]); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /357-Let Me Count The Ways.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector coins = {1,5,10,25,50}; 5 | vector dp(30001,0); 6 | 7 | int main() 8 | { 9 | dp[0] = 1; 10 | for(auto& coin : coins) 11 | for(int i=coin;i<30001;i++) 12 | dp[i] += dp[i-coin]; 13 | int n; 14 | while(scanf("%d",&n) != EOF){ 15 | if(dp[n] == 1) 16 | printf("There is only 1 way to produce %d cents change.\n",n); 17 | else 18 | printf("There are %lld ways to produce %d cents change.\n",dp[n],n); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /679-Dropping Balls.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,d,k; 7 | cin >> t; 8 | while(t--){ 9 | cin >> d >> k; 10 | int cur = 1; 11 | for(int i=1;i> t; 25 | } 26 | -------------------------------------------------------------------------------- /10104-Euclid Problem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int x,y,d; 5 | 6 | // ax + by = d 7 | // store x, y, and d as global variables 8 | void extendedEuclid(int a, int b) { 9 | if (b == 0) { x = 1; y = 0; d = a; return; } // base case 10 | extendedEuclid(b, a % b); // similar as the original gcd 11 | int x1 = y; 12 | int y1 = x - (a / b) * y; 13 | x = x1; 14 | y = y1; 15 | } 16 | 17 | int main() { 18 | int a,b; 19 | while(scanf("%d %d",&a,&b) != EOF) { 20 | extendedEuclid(a,b); 21 | printf("%d %d %d\n",x,y,d); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10551-Basic Remains.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(true){ 8 | int base = sc.nextInt(); 9 | if(base == 0) break; 10 | BigInteger p = new BigInteger(sc.next(),base); // convert base x string to base 10 11 | BigInteger m = new BigInteger(sc.next(),base); 12 | p = p.mod(m); 13 | System.out.println(p.toString(base)); // output as base x 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /11254-Consecutive Integers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n; 8 | while(scanf("%d",&n),n!=-1){ 9 | // brute force from higher range 10 | for(int range=sqrt(2*n); range>0; range--){ 11 | // arithmetic series to find first number 12 | int first = (2*n+range-range*range); 13 | if(first%(2*range)==0){ 14 | first/=(2*range); 15 | printf("%d = %d + ... + %d\n",n,first,first+range-1); 16 | break; 17 | } 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /1203-Argus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define pa pair 5 | 6 | int main() 7 | { 8 | string in; 9 | int q,p; 10 | priority_queue,greater> pq; 11 | unordered_map qToP; 12 | while(cin >> in, in != "#"){ 13 | cin >> q >> p; 14 | qToP[q] = p; 15 | pq.push({p,q}); 16 | } 17 | int k; 18 | cin >> k; 19 | while(k--){ 20 | pa top = pq.top(); pq.pop(); 21 | cout << top.second << endl; 22 | top.first += qToP[top.second]; 23 | pq.push(top); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /12049-Just Prune The List.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,m,v; 6 | cin >> t; 7 | while(t--){ 8 | cin >> n >> m; 9 | unordered_multiset s; 10 | int res = 0; 11 | while(n--){ 12 | cin >> v; 13 | s.insert(v); 14 | } 15 | while(m--){ 16 | cin >> v; 17 | auto it = s.find(v); 18 | if(it==s.end()) res++; 19 | else s.erase(it); 20 | } 21 | res += s.size(); 22 | cout << res << endl; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /902-Password Search.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | string in; 8 | int k; 9 | while(cin >> k){ 10 | unordered_map freqCount; 11 | cin >> in; 12 | for(int i=0;i+k<=in.length();i++){ 13 | string sub = in.substr(i,k); 14 | freqCount[sub]++; 15 | } 16 | pair res = {"",0}; 17 | for(auto& p : freqCount){ 18 | if(p.second > res.second) 19 | res = p; 20 | } 21 | cout << res.first << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10523-Very Easy !!!.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(sc.hasNext()){ 8 | int n = sc.nextInt(), a = sc.nextInt(); 9 | BigInteger aBig = BigInteger.valueOf(a); 10 | BigInteger res = BigInteger.ZERO; 11 | for(int i=1;i<=n;i++){ 12 | res = res.add(aBig.pow(i).multiply(BigInteger.valueOf(i))); 13 | } 14 | System.out.println(res); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /11420-Chest of Drawers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | // store [num drawers][num secured][bottom drawer locked?] 7 | long long dp[66][66][2] = {}; 8 | dp[1][1][1] = 1, dp[1][0][0] = 1; 9 | for(int i=2;i<=65;i++){ 10 | for(int s=0;s<=i;s++){ 11 | dp[i][s][0] = dp[i-1][s][0] + dp[i-1][s][1]; 12 | dp[i][s][1] = dp[i-1][s][0] + (s>0 ? dp[i-1][s-1][1] : 0); 13 | } 14 | } 15 | int n,s; 16 | while(scanf("%d %d",&n,&s), n>=0){ 17 | printf("%lld\n",dp[n][s][0] + dp[n][s][1]); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /256-Quirksome Squares.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map> precompute; 5 | 6 | void compute(int d){ 7 | int halfPow = ceil(pow(10,d/2)); 8 | int fullPow = halfPow*halfPow; 9 | for(int i=0;i 2 | using namespace std; 3 | typedef long long ll; 4 | 5 | void solve() { 6 | int n, m, k; 7 | while(cin >> n >> m >> k, (n+m+k) != 0) { 8 | int rleft = max(0, n-7); 9 | // compute number of white a & black b on last column 10 | int a = rleft/2, b = rleft-a; 11 | if(k) swap(a, b); // white more 1 12 | int cleft = max(0, m-7); 13 | int a2 = cleft/2, b2 = cleft-a2; 14 | ll res = 1LL*a*b2 + 1LL*b*a2; 15 | cout << res << "\n"; 16 | } 17 | } 18 | 19 | int main() { 20 | int t=1; 21 | while(t--) { 22 | solve(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /11342-Three-square.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,n; 8 | cin >> t; 9 | while(t--){ 10 | cin >> n; 11 | bool valid = false; 12 | for(int a=0;a*a= 0 && c-round(c) == 0){ 17 | valid = true; 18 | printf("%d %d %d\n",a,b,(int)c); 19 | } 20 | } 21 | if(!valid) printf("-1\n"); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /12583-Memory Overflow.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,k; 6 | string names; 7 | cin >> t; 8 | int cases = 1; 9 | while(t--){ 10 | cin >> n >> k >> names; 11 | unordered_multiset remember; 12 | int res = 0; 13 | for(int i=0;i=k) remember.erase(remember.find(names[i-k])); 17 | remember.insert(cur); 18 | } 19 | printf("Case %d: %d\n", cases++, res); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /231-Testing the CATCHER.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int v,tc=1; 7 | bool newline = false; 8 | while(scanf("%d",&v), v != -1){ 9 | if(tc>1) printf("\n"); 10 | vector res(1,v); 11 | while(scanf("%d",&v), v != -1){ 12 | auto it = lower_bound(res.rbegin(),res.rend(),v); 13 | if(it == res.rbegin()) res.push_back(v); 14 | else *prev(it) = v; 15 | } 16 | printf("Test #%d:\n",tc++); 17 | printf(" maximum possible interceptions: %d\n",(int)res.size()); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /10763-Foreign Exchange.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,a,b; 6 | while(scanf("%d",&n),n){ 7 | int remaining = n; 8 | unordered_map> fromTo; 9 | for(int i=0;i> a >> b; 11 | if(fromTo[b].count(a)){ 12 | remaining -= 2; 13 | fromTo[b].erase(fromTo[b].find(a)); 14 | } else { 15 | fromTo[a].insert(b); 16 | } 17 | } 18 | cout << (remaining == 0 ? "YES" : "NO") << endl; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /11621-Small Factors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector build(){ 5 | int i=0, j=0; 6 | vector res(1,1); 7 | while(res.back() <= 2147483648){ 8 | long long smallest = min(res[i]*2,res[j]*3); 9 | res.push_back(smallest); 10 | if(res[i]*2==smallest) i++; 11 | if(res[j]*3==smallest) j++; 12 | } 13 | return res; 14 | } 15 | 16 | int main() 17 | { 18 | vector nums = build(); 19 | int m; 20 | while(cin >> m, m){ 21 | cout << *lower_bound(nums.begin(),nums.end(),m) << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /12488-Start Grid.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,v; 6 | while(scanf("%d",&n) != EOF){ 7 | vector competitors; 8 | int res = 0; 9 | for(int i=0;i> v; 11 | competitors.push_back(v); 12 | } 13 | for(int i=0;i> v; 15 | auto it=competitors.begin(); 16 | for(;*it!=v;it++){ 17 | if(*it != -1) res++; 18 | } 19 | *it = -1; 20 | } 21 | cout << res << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /460-Overlapping Rectangles.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void solve() { 5 | int a, b, c, d; 6 | int z, x, y, w; 7 | cin >> a >> b >> c >> d >> z >> x >> y >> w; 8 | int l = max(a, z), r = min(c, y); 9 | int b2 = max(b, x), t = min(d, w); 10 | 11 | if(l>=r || t<=b2) { 12 | cout << "No Overlap\n"; 13 | return; 14 | } 15 | cout << l << " " << b2 << " " << r << " " << t << "\n"; 16 | } 17 | 18 | int main() { 19 | int t=1; 20 | cin >> t; 21 | bool first = true; 22 | while(t--) { 23 | if(!first) cout << "\n"; 24 | first = false; 25 | solve(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /484-The Department of Redundancy Department.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | unordered_map valToIdx; 10 | vector> res; 11 | int v; 12 | while(cin >> v){ 13 | if(!valToIdx.count(v)){ 14 | valToIdx[v] = res.size(); 15 | res.push_back({v,0}); 16 | } 17 | int idx = valToIdx[v]; 18 | res[idx].second++; 19 | } 20 | for(auto it=res.begin();it!=res.end();it++) 21 | cout << it->first << " " << it->second << endl; 22 | } 23 | -------------------------------------------------------------------------------- /10405-Longest Common Subsequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | string a,b; 7 | while(getline(cin,a)){ 8 | getline(cin,b); 9 | vector dp(b.length()+1); 10 | for(int i=0;i 2 | 3 | using namespace std; 4 | #define N 1000001 5 | #define ll long long 6 | vector numDiffPF; 7 | 8 | // compute num of different PF each number have 9 | void modifiedSieve(){ 10 | numDiffPF.assign(N, 0); 11 | for(long long i=2;i 2 | 3 | using namespace std; 4 | #define PI 2*acos(0) 5 | 6 | struct point { 7 | double x, y; 8 | point() { x = y = 0.0; } 9 | point(double _x, double _y) : x(_x), y(_y) {} 10 | }; 11 | 12 | // area of ellipse = a*b*pi, where a and b are half of minor and major axes 13 | int main() { 14 | int n; 15 | double d,l; 16 | scanf("%d",&n); 17 | while(n--) { 18 | scanf("%lf %lf",&d,&l); 19 | double a = l/2; 20 | double b = sqrt(l/2*l/2-d/2*d/2); 21 | double area = PI*a*b; 22 | printf("%.3f\n",area); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /11572-Unique Snowflakes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t, n, v; 6 | scanf("%d",&t); 7 | while(t--){ 8 | cin >> n; 9 | unordered_map lastSeen; 10 | int lastIdxWithoutDup = 0; 11 | int longest = 0, res = 0; 12 | for(int i=1;i<=n;i++){ 13 | cin >> v; 14 | int last = lastSeen[v]; 15 | lastIdxWithoutDup = max(last,lastIdxWithoutDup); 16 | res = max(i-lastIdxWithoutDup, res); 17 | lastSeen[v] = i; 18 | } 19 | cout << res << endl; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /11991-Easy Problem from Rujia Liu.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,m,k,v; 6 | while(scanf("%d %d\n",&n,&m) != EOF){ 7 | unordered_map> posMap; 8 | for(int i=1;i<=n;i++){ 9 | cin >> v; 10 | posMap[v].push_back(i); 11 | } 12 | for(int i=0;i> k >> v; 14 | k--; 15 | vector& posVec = posMap[v]; 16 | if(k>=posVec.size()) cout << 0 << endl; 17 | else cout << posVec[k] << endl; 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /11062-Andy's Second Dictionary.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string in="",in2; 6 | set distinct; 7 | bool concat = false; 8 | while(getline(cin,in2)){ 9 | in += in2; 10 | if(in.back() == '-') { 11 | concat = true; 12 | in.pop_back(); 13 | } else in += " "; 14 | } 15 | in = regex_replace(in,regex("[^a-zA-Z\-]")," "); 16 | transform(in.begin(),in.end(),in.begin(),::tolower); 17 | istringstream iss(in); 18 | while(iss >> in) distinct.insert(in); 19 | for(auto& s : distinct) cout << s << endl; 20 | } 21 | -------------------------------------------------------------------------------- /11286-Conformity.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int v; 6 | int a,b,c,d,e; 7 | map,int> cnt; 8 | while(cin >> v, v){ 9 | cnt.clear(); 10 | int high = 0; 11 | while(v--){ 12 | cin >> a >> b >> c >> d >> e; 13 | vector input={a,b,c,d,e}; 14 | sort(input.begin(),input.end()); 15 | high = max(high,++cnt[input]); 16 | } 17 | int res = 0; 18 | for(auto& p : cnt) { 19 | if(p.second == high) res++; 20 | } 21 | cout << res*high << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /11827-Maximum GCD.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int gcd(int a, int b){ 6 | return a==0 ? b : gcd(b%a, a); 7 | } 8 | 9 | int main() 10 | { 11 | int n,v; 12 | string in; 13 | scanf("%d\n",&n); 14 | for(int i=0;i vals; 18 | while(iss >> v) vals.push_back(v); 19 | int res = 0; 20 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,l,m; 7 | while(scanf("%d",&n),n){ 8 | vector> blockCount(101,vector(101)); 9 | vector> dp(101,vector(101)); 10 | for(int i=0;i 2 | using namespace std; 3 | 4 | // can be further optimized by doing character swapping at each pos 5 | 6 | void dfs(string& in,int idx,string cur){ 7 | if(cur.length() == in.length()){ 8 | cout << cur << endl; 9 | return; 10 | } 11 | for(int i=0;i<=cur.length();i++){ 12 | dfs(in,idx+1,cur.substr(0,i)+in[idx]+cur.substr(i)); 13 | } 14 | } 15 | 16 | int main() 17 | { 18 | string in; 19 | bool notfirst = false; 20 | while(cin >> in){ 21 | if(notfirst) cout << endl; 22 | notfirst = true; 23 | dfs(in,0,""); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /389-Basically Speaking.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(sc.hasNext()){ 8 | String input = sc.next(); 9 | int baseFrom = sc.nextInt(), baseTo = sc.nextInt(); 10 | BigInteger convert = new BigInteger(input,baseFrom); 11 | String convertTo = convert.toString(baseTo).toUpperCase(); 12 | if(convertTo.length() > 7) convertTo = "ERROR"; 13 | System.out.println(String.format("%7s",convertTo)); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /729-The Hamming Distance Problem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void backtrack(string& cur, int level, int idx, int h){ 5 | if(level == h){ 6 | cout << cur << endl; 7 | return; 8 | } else if(idx >= cur.length()) return; 9 | backtrack(cur,level,idx+1,h); 10 | cur[idx] = '1'; 11 | backtrack(cur,level+1,idx+1,h); 12 | cur[idx] = '0'; 13 | } 14 | 15 | int main() 16 | { 17 | int t; 18 | int n,h; 19 | cin >> t; 20 | while(t--){ 21 | cin >> n >> h; 22 | string cur(n,'0'); 23 | backtrack(cur,0,0,h); 24 | if(t) cout << endl; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /417-Word Index.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | unordered_map idxMap; 10 | int idx = 1; 11 | queue patterns; 12 | for(char c='a';c<='z';c++) patterns.push(string{c}); 13 | while(!patterns.empty()){ 14 | string top = patterns.front(); patterns.pop(); 15 | idxMap[top] = idx++; 16 | if(top.length() == 5) continue; 17 | for(char c=top.back()+1;c<='z';c++) patterns.push(top + c); 18 | } 19 | string in; 20 | while(cin >> in){ 21 | cout << idxMap[in] << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10721-Bar Codes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int n,k,m; 5 | long long memo[51][51]; 6 | long long solve(int remLength, int remK){ 7 | if(remLength == 0 && remK == 0) return 1; 8 | else if(remK == 0 || remLength <=0) return 0; 9 | if(memo[remLength][remK] != -1) return memo[remLength][remK]; 10 | long long res = 0; 11 | for(int i=1;i<=m;i++) 12 | res += solve(remLength-i, remK-1); 13 | return memo[remLength][remK] = res; 14 | } 15 | 16 | int main() { 17 | while(scanf("%d %d %d",&n,&k,&m) != EOF){ 18 | memset(memo,-1,sizeof memo); 19 | printf("%lld\n", solve(n,k)); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /10338-Mischievous Children.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long factorial(int k) 6 | { 7 | long long res = 1; 8 | for(int i=2;i<=k;i++) res *= i; 9 | return res; 10 | } 11 | 12 | int main() 13 | { 14 | int n; 15 | string in; 16 | scanf("%d\n",&n); 17 | int tc = 1; 18 | while(n--) { 19 | getline(cin, in); 20 | unordered_map cntMap; 21 | long long res = factorial(in.size()); 22 | for(auto c : in) cntMap[c]++; 23 | for(auto& p : cntMap) 24 | res /= factorial(p.second); 25 | printf("Data set %d: %lld\n", tc++, res); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /10446-The Marriage Interview :-).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unsigned long long memo[62][62]; 5 | 6 | unsigned long long trib(int n, unsigned int back) 7 | { 8 | if(n <= 1) return 1; 9 | else if(memo[n][back] != 0) return memo[n][back]; 10 | // start with 1 as this function is called 11 | unsigned long long sum = 1; 12 | for(int i=1;i<=back;i++) sum += trib(n-i,back); 13 | 14 | return memo[n][back] = sum; 15 | } 16 | 17 | int main() 18 | { 19 | int a,b,tc=1; 20 | while(scanf("%d %d",&a,&b) != EOF){ 21 | if(a > 60) break; 22 | printf("Case %d: %llu\n",tc++,trib(a,b)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /12485-Perfect Choir.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,v; 6 | while(scanf("%d",&n) != EOF){ 7 | vector members; 8 | int sum = 0; 9 | for(int i=0;i> v; 11 | members.push_back(v); 12 | sum += v; 13 | } 14 | if(sum%n == 0){ 15 | // optimal result is to shift everyone to mean 16 | int avg = sum/n; 17 | int error = 0; 18 | for(auto& member : members) error += abs(avg-member); 19 | printf("%d\n",1+error/2); 20 | } else printf("-1\n"); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /10252-Common Permutation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | string a,b; 8 | while(getline(cin,a)){ 9 | getline(cin,b); 10 | int aCount[26] = {}; 11 | int bCount[26] = {}; 12 | for(auto& c : a){ 13 | aCount[c-'a']++; 14 | } 15 | for(auto& c : b){ 16 | bCount[c-'a']++; 17 | } 18 | string res = ""; 19 | for(int i=0;i<26;i++){ 20 | int common = min(aCount[i],bCount[i]); 21 | for(int j=0;j 0){ 9 | BigInteger numerator = sc.nextBigInteger(); 10 | sc.next(); 11 | BigInteger denominator = sc.nextBigInteger(); 12 | BigInteger gcd = numerator.gcd(denominator); 13 | numerator = numerator.divide(gcd); 14 | denominator = denominator.divide(gcd); 15 | System.out.println(numerator + " / " + denominator); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /10056-What is the Probability ?.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(4); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | void solve() { 8 | int n; 9 | double p; 10 | int i; 11 | cin >> n >> p >> i; 12 | if(p==0) { 13 | cout << p << "\n"; 14 | return; 15 | } 16 | // solve for F[i] = prob-win + prob-lose = (1-P)^(i-1) * P + (1-P)^n * F[i] 17 | double res = pow((1.0 - p), i-1) * p / (1.0 - pow(1.0 - p, n)); 18 | cout << res << "\n"; 19 | } 20 | 21 | int main() { 22 | int t=1; 23 | cin >> t; 24 | while(t--) { 25 | solve(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /10843-Anne's game.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | constexpr ll mod = 2000000011; 9 | ll powe(ll x, ll e) { 10 | ll res = 1; 11 | while(e) { 12 | if(e&1) res = x*res%mod; 13 | e >>= 1; 14 | x = x*x%mod; 15 | } 16 | return res; 17 | } 18 | 19 | int main() { 20 | int t=1; 21 | cin >> t; 22 | for(int tc=1;tc<=t;tc++) { 23 | ll x; 24 | cin >> x; 25 | ll v = x<=2 ? 1 : powe(x, x-2); 26 | cout << "Case #" << tc << ": "; 27 | cout << v << "\n"; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10394-Twin Primes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | vector twinPrimes; 6 | bitset<20000001> isPrime; 7 | void sieve(){ 8 | isPrime.set(); 9 | isPrime[0] = isPrime[1] = false; 10 | for(long long i=2;i<20000001;i++){ 11 | if(isPrime[i]){ 12 | for(long long j=i*i;j<20000001;j+=i){ 13 | isPrime[j] = false; 14 | } 15 | if(isPrime[i-2]) 16 | twinPrimes.push_back(i); 17 | } 18 | } 19 | } 20 | 21 | int main() { 22 | sieve(); 23 | int n; 24 | while(scanf("%d",&n) != EOF){ 25 | printf("(%d, %d)\n",twinPrimes[n-1]-2,twinPrimes[n-1]); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /10790-How Many Points of Intersection?.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | 9 | 10 | void solve() { 11 | ll a, b; 12 | int tc= 1; 13 | while(cin >> a >> b, (a+b)) { 14 | ll nc2_a = a*(a-1)/2, nc2_b = b*(b-1)/2; // number of pairs in each row 15 | // 1 pair from a & 1 pair from b = 1 intersection 16 | cout << "Case " << tc++ << ": "; 17 | cout << nc2_a * nc2_b << "\n"; 18 | } 19 | } 20 | 21 | int main() { 22 | int t=1; 23 | while(t--) { 24 | solve(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /471-Magic Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool isValid(long long n){ 5 | bool taken[10] = {false}; 6 | while(n){ 7 | int cur = n%10; 8 | if(taken[cur]) return false; 9 | taken[cur] = true; 10 | n /= 10; 11 | } 12 | return true; 13 | } 14 | 15 | int main() { 16 | int t; 17 | cin >> t; 18 | long long n; 19 | while(t--){ 20 | cin >> n; 21 | for(long long i=1;i*n<=9876543210;i++){ 22 | long long j = i*n; 23 | if(isValid(j) && isValid(i)) 24 | printf("%lld / %lld = %lld\n",j,i,n); 25 | } 26 | if(t)cout << endl; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /10812-Beat the Spread!.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | typedef long long ll; 7 | 8 | const string IMP = "impossible"; 9 | void solve() { 10 | ll s, d; 11 | cin >> s >> d; 12 | ll a2 = s+d; 13 | if(a2%2) { 14 | cout << IMP << "\n"; 15 | return; 16 | } 17 | ll a = a2/2; 18 | ll b = s-a; 19 | if(b<0) { 20 | cout << IMP << "\n"; 21 | return; 22 | } 23 | cout << a << " " << b << "\n"; 24 | } 25 | 26 | int main() { 27 | int t=1; 28 | cin >> t; 29 | while(t--) { 30 | solve(); 31 | } 32 | } 33 | 34 | -------------------------------------------------------------------------------- /11350-Stern-Brocot Tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | string str; 7 | scanf("%d\n",&n); 8 | while(n--){ 9 | getline(cin,str); 10 | pair left = {0,1}, right = {1,0}, cur = {1,1}; 11 | for(auto& c : str){ 12 | if(c == 'R'){ 13 | left = cur; 14 | cur = {cur.first+right.first, cur.second+right.second}; 15 | } else { 16 | right = cur; 17 | cur = {cur.first+left.first, cur.second+left.second}; 18 | } 19 | } 20 | cout << cur.first << "/" << cur.second << endl; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /11917-Do Your Own Homework.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,c,s,d; 6 | int cases=1; 7 | string sub; 8 | scanf("%d",&t); 9 | while(t--){ 10 | unordered_map subDays; 11 | cin >> s; 12 | while(s--){ 13 | cin >> sub >> c; 14 | subDays[sub] = c; 15 | } 16 | cin >> d; 17 | cin >> sub; 18 | cout << "Case " << cases++ << ": "; 19 | if(!subDays.count(sub) || subDays[sub] > d+5) cout << "Do your own homework!"; 20 | else if(subDays[sub] <= d) cout << "Yesss"; 21 | else cout << "Late"; 22 | cout << endl; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /10407-Simple division.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // idea: 4 | // congruence relation 5 | // if a%d == b%d, then (a-b)%d = 0 6 | // thus d is a divisor than leave no remainder for (v2-v1)/d 7 | // solution is thus to find the gcd of all (v1-v2), all pairs 8 | // either gcd(v2-v1, v3-v2) or gcd(v3-v1,v3-v2) will work 9 | 10 | using namespace std; 11 | 12 | int gcd(int a, int b){ 13 | return a==0 ? b : gcd(b%a, a); 14 | } 15 | 16 | int main() 17 | { 18 | int first, val; 19 | while(scanf("%d",&first), first != 0){ 20 | int res = 0; 21 | while(scanf("%d",&val), val != 0) 22 | res = gcd(res, val-first); 23 | printf("%d\n", abs(res)); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /11389-The Bus Driver Problem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,d,r,v; 6 | while(scanf("%d %d %d",&n,&d,&r),n){ 7 | vector morning, evening; 8 | for(int i=0;i<2*n;i++){ 9 | cin >> v; 10 | if(i()); 15 | int res = 0; 16 | for(int i=0;i d) res += (dist-d)*r; 19 | } 20 | printf("%d\n",res); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /1225-Digit Counting.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | vector> res(10001,vector(10)); 7 | for(int i=1;i<=10000;i++){ 8 | res[i] = res[i-1]; 9 | int n = i; 10 | while(n!=0){ 11 | int val = n%10; 12 | n/=10; 13 | res[i][val]++; 14 | } 15 | } 16 | int t,v; 17 | scanf("%d",&t); 18 | while(t--){ 19 | scanf("%d",&v); 20 | for(auto& val : res[v]){ 21 | printf("%d",val); 22 | if(&val == &res[v].back()) 23 | printf("\n"); 24 | else 25 | printf(" "); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /10192-Vacation.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | string a,b; 5 | 6 | int main() 7 | { 8 | int tc=1; 9 | while(getline(cin,a), a != "#"){ 10 | getline(cin,b); 11 | vector dp(b.length()+1); 12 | for(int i=0;i nextDp(b.length()+1); 14 | for(int j=0;j 2 | using namespace std; 3 | // find x,y such that x*y = k*y+k*x 4 | // y = (x*k)/(x-k), if check x*k with mod of x-k, then there exist a y 5 | 6 | int main() { 7 | int k; 8 | while(scanf("%d",&k) != EOF){ 9 | vector> res; 10 | // check until 2*k, the highest possible val for x or y 11 | for(int x=k+1;x<=2*k;x++){ 12 | if(((x*k) % (x-k)) != 0) continue; 13 | int y = (x*k)/(x-k); 14 | res.push_back({y,x}); 15 | } 16 | cout << res.size() << endl; 17 | for(auto& p : res){ 18 | printf("1/%d = 1/%d + 1/%d\n",k,p.first,p.second); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /10774-Repeated Josephus.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // get last survivor of josephus iteration 5 | int josephus(int n, int k) { 6 | int s = 0; 7 | for(int i=2;i<=n;i++) 8 | s = (s+k)%i; // next person after the one that is killed 9 | return s+1; 10 | } 11 | 12 | int main() { 13 | int t,n; 14 | scanf("%d",&t); 15 | for(int tc=1;tc<=t;tc++) { 16 | scanf("%d",&n); 17 | int iteration = 0; 18 | while(1) { 19 | int survive = josephus(n, 2); 20 | iteration++; 21 | if(survive == n) break; 22 | n = survive; 23 | } 24 | printf("Case %d: %d %d\n", tc, iteration-1, n); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /10912-Simple Minded Hashing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int memo[27][352][27]; 4 | 5 | int solve(int remLen, int val, int pos){ 6 | if(remLen == 0 && val == 0) return 1; 7 | else if(remLen <= 0 || val <= 0 || pos> 26) return 0; 8 | if(memo[remLen][val][pos] != -1) return memo[remLen][val][pos]; 9 | 10 | int res = 0; 11 | for(int i=pos;i<=26;i++) 12 | res += solve(remLen-1,val-i,i+1); 13 | return memo[remLen][val][pos] = res; 14 | } 15 | 16 | int main() 17 | { 18 | memset(memo,-1,sizeof memo); 19 | int tc=1,l,s; 20 | while(scanf("%d %d",&l,&s),(l+s)!=0){ 21 | printf("Case %d: %d\n",tc++, (l > 26 || s > 352) ? 0 : solve(l,s,1)); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /11103-WFF 'N PROOF.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string in; 6 | while(getline(cin,in),in!= "0"){ 7 | string lower = ""; 8 | string upper = ""; 9 | int n = 0; 10 | for(auto& c : in){ 11 | if(c == 'N') n++; 12 | else if(isupper(c)) upper += c; 13 | else lower += c; 14 | } 15 | if(lower.empty()) printf("no WFF possible\n"); 16 | else { 17 | while(n--) printf("N"); 18 | for(int i=1,j=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,p,n,b; 7 | cin >> t; 8 | while(t--){ 9 | cin >> p; 10 | cin >> n; 11 | vector bills; 12 | int sum = 0; 13 | for(int i=0;i> b; 15 | bills.push_back(b); 16 | sum+=b; 17 | } 18 | vector dp(sum+1,1e8); 19 | dp[0] = 0; 20 | for(auto& bill : bills) 21 | for(int i=sum;i>=bill;i--) 22 | if(dp[i-bill] != 1e8) 23 | dp[i] = min(dp[i],dp[i-bill]+1); 24 | 25 | while(dp[p]==1e8)p++; 26 | printf("%d %d\n",p,dp[p]); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /11264-Coin Collector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,v; 6 | scanf("%d",&t); 7 | while(t--){ 8 | scanf("%d",&n); 9 | vector coins; 10 | for(int i=0;i> v; 12 | coins.push_back(v); 13 | } 14 | int curSum = 0, res=0; 15 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | string str; 6 | int n,v; 7 | bool first = true; 8 | while(cin >> n, n){ 9 | vector in; 10 | if(!first) cout << endl; 11 | first = false; 12 | while(n--) { 13 | cin >> v; 14 | in.push_back(v); 15 | } 16 | for(int i=0;i 2 | using namespace std; 3 | #define fastio ios_base::sync_with_stdio(false);cin.tie(NULL); 4 | 5 | int main(){ 6 | fastio 7 | int t, n, m; 8 | char s; 9 | cin >> t; 10 | while(t--) { 11 | cin >> s >> n >> m; 12 | int res; 13 | if(s=='r') { 14 | res = min(n, m); 15 | } else if(s=='Q') { 16 | res = min(n, m); //queen problem always have solution for n>=4 17 | } else if(s=='K') { 18 | res = ((n+1)/2) * ((m+1)/2); // 1king take four cells 19 | } else if(s=='k') { 20 | res = (n*m)%2 ? n*m/2+1 : n*m/2; // knight occupy one color 21 | } 22 | cout << res << "\n"; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /412-Pi.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(6); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | void solve() { 8 | int n; 9 | while(cin >> n, n) { 10 | vector vals(n); 11 | int total = n*(n-1)/2; 12 | for(int i=0;i> vals[i]; 13 | int cnt = 0; 14 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int t,p; 6 | string in; 7 | scanf("%d\n",&t); 8 | while(t--){ 9 | scanf("%d\n",&p); 10 | int minSize = p; 11 | vector res; 12 | for(int i=1;i<=p;i++){ 13 | getline(cin,in); 14 | istringstream iss(in); 15 | int cur = 0; 16 | while(iss>>in) cur++; 17 | if(cur 2 | using namespace std; 3 | 4 | int main() { 5 | int f,r,v; 6 | while(scanf("%d",&f),f){ 7 | cin >> r; 8 | vector teethF; 9 | vector ratios; 10 | for(int i=0;i> v; 12 | teethF.push_back(v); 13 | } 14 | for(int i=0;i> v; 16 | for(auto& v2 : teethF){ 17 | ratios.push_back((double)v/v2); 18 | } 19 | } 20 | sort(ratios.begin(), ratios.end()); 21 | double res = DBL_MIN; 22 | for(int i=1;i 2 | using namespace std; 3 | // can be also solved using dp in O(N*P) = 20000 4 | // complete search is better here O(2^P) = 20^2 = 400 5 | 6 | int main() { 7 | int t,n,p,v; 8 | cin >> t; 9 | while(t--){ 10 | cin >> n >> p; 11 | vector nums; 12 | for(int i=0;i> v; 14 | nums.push_back(v); 15 | } 16 | bool found = false; 17 | for(int i=0;i<(1< 2 | using namespace std; 3 | 4 | // Pisano Period: the last 1,2,3,4 digits of fibonacci seq 5 | // repeats with a period of 60/300/1500/15000 6 | 7 | vector period = {60,300,1500,15000}; 8 | vector mod = {10,100,1000,10000}; 9 | 10 | int main() 11 | { 12 | int t,a,b,n,m; 13 | scanf("%d",&t); 14 | while(t--){ 15 | scanf("%d %d %d %d",&a,&b,&n,&m); 16 | // generate seq up to period 17 | n %= period[m-1]; 18 | vector fib; 19 | fib.push_back(a % mod[m-1]), fib.push_back(b % mod[m-1]); 20 | for(int i=2;i<=n;i++) 21 | fib.push_back((fib[i-1]+fib[i-2]) % mod[m-1]); 22 | printf("%d\n",fib[n]); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /11285-Exchange Rates.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n; 7 | double day; 8 | while(scanf("%d",&n),n){ 9 | int best_can = 100000, best_us = 0; 10 | // greedy + dp 11 | // each day we try to convert from all from one currency to another, track the max 12 | for(int i=0;i 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | int main() { 8 | string in; 9 | while(getline(cin, in)) { 10 | istringstream iss(in); 11 | vector coeff, xs; 12 | int c; 13 | while(iss >> c) coeff.push_back(c); 14 | getline(cin, in); 15 | iss = istringstream(in); 16 | while(iss >> c) xs.push_back(c); 17 | 18 | for(int i=0;i=0;j--) { 22 | sum += coeff[j]*x; 23 | x *= xs[i]; 24 | } 25 | cout << sum << " \n"[i==xs.size()-1]; 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /957-Popes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int y,n,v; 7 | while(cin >> y){ 8 | cin >> n; 9 | vector years; 10 | for(int i=0;i> v; 12 | years.push_back(v); 13 | } 14 | int best=0, from=0, to=0; 15 | for(int i=0;i best){ 19 | best = numPopes; 20 | from = years[i]; 21 | to = *prev(upper); 22 | } 23 | } 24 | printf("%d %d %d\n",best,from,to); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /10925-Krakovia.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | int tc=1; 8 | while(true){ 9 | int n = sc.nextInt(), f = sc.nextInt(); 10 | if(n==0&&f==0) break; 11 | BigInteger sum = BigInteger.ZERO; 12 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | int a,b,c; 7 | cin >> n; 8 | while(n--){ 9 | cin >> a >> b >> c; 10 | bool solved = false; 11 | // 10000^(1/3) = 22 12 | for(int x = -22; x<= 22; x++) if(x*x <= c) 13 | for(int y = -100; y <= 100; y++) 14 | for(int z = - 100; z <= 100; z++){ 15 | if(z == x || z == y || x == y) continue; 16 | if(x+y+z == a && x*y*z == b && x*x+y*y+z*z == c){ 17 | solved = true; 18 | printf("%d %d %d\n",x,y,z); 19 | goto outer; 20 | } 21 | } 22 | outer: 23 | if(!solved) printf("No solution.\n"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /1207-AGTC.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n1,n2; 8 | string a,b; 9 | while(cin >> n1){ 10 | cin >> a >> n2 >> b; 11 | vector dp(b.length()+1); 12 | for(int i=0;i<=b.length();i++) 13 | dp[i] = i; 14 | for(int i=0;i dpNext(b.length()+1); 16 | dpNext[0] = i+1; 17 | for(int j=0;j 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | using namespace std; 20 | 21 | int main() { 22 | int v; 23 | while(scanf("%d",&v) == 1){ 24 | int res = 0, init = v; 25 | for(int i=0;i<4;i++, v>>=8){ 26 | res <<= 8; 27 | res |= (v) & 0xFF; 28 | } 29 | printf("%d converts to %d\n",init,res); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /11634-Generate random numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n; 8 | while(scanf("%lld",&n),n){ 9 | auto f = [](int x) { 10 | return (x*x/100)%10000; 11 | }; 12 | int res = 1; 13 | int slow = n, fast = n; 14 | while(true){ 15 | slow = f(slow); 16 | fast = f(f(fast)); 17 | if(slow == fast) break; 18 | } 19 | slow = n; 20 | while(slow != fast){ 21 | slow = f(slow), fast = f(fast); 22 | res++; 23 | } 24 | slow = f(fast); 25 | while(slow != fast) { 26 | res++; 27 | slow = f(slow); 28 | } 29 | printf("%d\n",res); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /1261-String Popping.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | unordered_map valid; 5 | 6 | bool canEmpty(string in){ 7 | if(in.empty()) return true; 8 | if(valid.count(in)) return valid[in]; 9 | int i=0; 10 | bool can = false; 11 | while(i> t; 25 | while(t--){ 26 | cin >> in; 27 | valid.clear(); 28 | if(canEmpty(in)) printf("1\n"); 29 | else printf("0\n"); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /386-Perfect Cubes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | for(int i=6;i<=200;i++){ 8 | int aCube = i*i*i; 9 | for(int j=2;j 2 | using namespace std; 3 | 4 | vector primes; 5 | vector> dp(1121,vector(15)); 6 | 7 | void sieve(){ 8 | bitset<1121> bs; 9 | bs.set(); 10 | for(int i=2;i<1121;i++) 11 | if(bs[i]){ 12 | primes.push_back(i); 13 | for(int j=i*i;j<1121;j+=i) bs[j] = false; 14 | } 15 | } 16 | 17 | void knapsack(){ 18 | dp[0][0] = 1; 19 | for(auto& prime : primes){ 20 | for(int i=1120;i>=prime;i--) 21 | for(int j=1;j<15;j++) 22 | dp[i][j] += dp[i-prime][j-1]; 23 | } 24 | } 25 | 26 | int main() 27 | { 28 | sieve(); 29 | knapsack(); 30 | int n,k; 31 | while(scanf("%d %d",&n,&k),n||k){ 32 | printf("%d\n",dp[n][k]); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /10583-Ubiquitous Religions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int groupCount; 5 | 6 | int udfsFind(int* udfs, int n){ 7 | return udfs[n] == n ? n : udfsFind(udfs,udfs[n]); 8 | } 9 | 10 | void udfsJoin(int* udfs, int a, int b){ 11 | if(udfsFind(udfs,a) == udfsFind(udfs,b)) return; 12 | udfs[udfsFind(udfs,a)] = udfsFind(udfs,b); 13 | groupCount--; 14 | } 15 | 16 | int main() { 17 | int n,m,a,b; 18 | int cases=1; 19 | while(scanf("%d %d",&n,&m),n||m){ 20 | int udfs[n]; 21 | groupCount = n; 22 | for(int i=0;i> a >> b; 25 | udfsJoin(udfs,a-1,b-1); 26 | } 27 | printf("Case %d: %d\n",cases++,groupCount); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /11151-Longest Palindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t; 7 | string in; 8 | scanf("%d\n",&t); 9 | while(t--){ 10 | getline(cin,in); 11 | vector> dp(in.length(),vector(in.length(),0)); 12 | 13 | for(int j=in.length()-1;j>=0;j--){ 14 | dp[j][j] = 1; 15 | for(int i=j+1;i 2 | 3 | using namespace std; 4 | int res[10000000] = {}; 5 | 6 | bool isValid(int n){ 7 | bool taken[10] = {}; 8 | string str = to_string(n); 9 | int idx = 0; 10 | int size = str.length(); 11 | unordered_set reachedIdx; 12 | while(reachedIdx.size() != size){ 13 | int moves = str[idx] - '0'; 14 | idx = (idx+moves) % size; 15 | if(reachedIdx.count(idx) || taken[moves]) return false; 16 | reachedIdx.insert(idx); 17 | taken[moves] = true; 18 | } 19 | return idx == 0; 20 | } 21 | 22 | int main() 23 | { 24 | int cases = 1; 25 | int n; 26 | for(int i=9999998;i>=0;i--) res[i] = isValid(i) ? i : res[i+1]; 27 | while(scanf("%d",&n),n) printf("Case %d: %d\n",cases++,res[n]); 28 | } 29 | -------------------------------------------------------------------------------- /562-Dividing coins.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,n,v; 7 | scanf("%d",&t); 8 | while(t--){ 9 | scanf("%d",&n); 10 | int sum = 0; 11 | vector coins; 12 | for(int i=0;i dp(sum/2+1); 18 | dp[0] = true; 19 | int highest = 0; 20 | for(auto& coin : coins){ 21 | for(int i=sum/2;i>=coin;i--){ 22 | dp[i] = dp[i-coin] ? true : dp[i]; 23 | if(dp[i]) highest = max(i,highest); 24 | } 25 | } 26 | int res = sum-highest*2; 27 | printf("%d\n",res); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10003-Cutting Sticks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int l, n, cut[55], memo[55][55]; 5 | 6 | int minCost(int left, int right){ 7 | if(left+1 == right) return 0; 8 | if(memo[left][right] != -1) return memo[left][right]; 9 | int res = 1e8; 10 | // try each cutting spot 11 | for(int i=left+1;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t; 7 | // use double, 26! is too large 8 | double factorial[27] = {}; 9 | factorial[0] = factorial[1] = 1; 10 | for(int i=2;i<27;i++) factorial[i] = factorial[i-1]*i; 11 | 12 | cin >> t; 13 | string in; 14 | double n; 15 | while(t--){ 16 | cin >> in >> n; 17 | string res = ""; 18 | n--; // start from 0 instead of 1 19 | double total = factorial[in.length()]; 20 | for(int i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main() { 18 | int t; 19 | string in; 20 | while(scanf("%d",&t), t){ 21 | vector vals; 22 | while(t--){ 23 | cin >> in; 24 | vals.push_back(in); 25 | } 26 | sort(vals.begin(),vals.end(),[](string& a, string& b){ 27 | return a+b > b+a; 28 | }); 29 | for(auto&s : vals) cout< 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,m; 7 | while(scanf("%d %d",&n,&m),n||m){ 8 | vector> dp(n+1,vector(m+1)); 9 | for(int i=1;i<=n;i++) 10 | for(int j=1;j<=m;j++){ 11 | scanf("%d",&dp[i][j]); 12 | dp[i][j] += (dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1]); 13 | } 14 | int best = 0; 15 | for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) 16 | for(int k=i;k<=n;k++) for(int l=j;l<=m;l++){ 17 | int cur = dp[k][l] - dp[i-1][l] - dp[k][j-1] + dp[i-1][j-1]; 18 | if(cur == 0) 19 | best = max(best,(k-i+1)*(l-j+1)); 20 | // we can do additional pruning if not 0 21 | } 22 | printf("%d\n",best); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /10152-ShellSort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n; 6 | string in; 7 | cin >> t; 8 | while(t--){ 9 | cin >> n; 10 | cin.ignore(); 11 | vector original, expected; 12 | for(int i=0;i<2*n;i++){ 13 | getline(cin,in); 14 | if(i=0;i--) 20 | // since they have a match, advance to next 21 | if(original[i] == expected[j]) j--; 22 | // sort the rest by putting them on top 23 | while(j>=0){ 24 | cout << expected[j--] << endl; 25 | } 26 | cout << endl; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /10664-Luggage.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,v; 7 | string in; 8 | scanf("%d\n",&t); 9 | while(t--){ 10 | getline(cin,in); 11 | istringstream iss(in); 12 | vector nums; 13 | int sum = 0; 14 | while(iss >> v){ 15 | sum += v; 16 | nums.push_back(v); 17 | } 18 | if(sum%2) printf("NO\n"); 19 | else { 20 | sum/=2; 21 | vector dp(sum+1); 22 | dp[0] = true; 23 | for(auto& num : nums){ 24 | for(int i=sum;i>=num;i--) 25 | dp[i] = dp[i-num] ? true : dp[i]; 26 | } 27 | if(dp[sum]) printf("YES\n"); 28 | else printf("NO\n"); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /10036-Divisibility.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,n,k,v; 7 | cin >> t; 8 | while(t--){ 9 | cin >> n >> k; 10 | vector dp(k,false); 11 | dp[0] = true; 12 | for(int i=0;i> v; 14 | vector dpNext(k,false); 15 | // can try using an unordered_set on j for better performance 16 | for(int j=0;j 2 | using namespace std; 3 | 4 | int main() { 5 | vector> turtles; 6 | int w,s; 7 | while(scanf("%d %d",&w,&s) == 2) { 8 | turtles.push_back({s,w}); 9 | } 10 | // (greedy) sort by min strength, because they can carry less 11 | sort(turtles.begin(), turtles.end()); 12 | vector dp(turtles.size(),1e7); // dp of minimum weight for stack size i 13 | dp[0] = 0; 14 | int res = 0; 15 | for(int i=0;i=0;j--){ 17 | if(turtles[i].first - turtles[i].second - dp[j] < 0) continue; 18 | dp[j+1] = min(dp[j+1], dp[j]+turtles[i].second); // minimize stack weight 19 | res = max(res, j+1); 20 | } 21 | } 22 | printf("%d\n", res); 23 | } 24 | -------------------------------------------------------------------------------- /108-Maximum Sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n; 7 | cin >> n; 8 | vector> dp(n,vector(n)); 9 | for(int i=0;i 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(6); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | 9 | // observation: sum(2^i) from 0 to i <= 2^(i+1), thus only last round matter 10 | void solve() { 11 | int n, k; 12 | while(cin >> n >> k, (n+k)) { 13 | vector vals(n); 14 | for(int i=0;i> v; 17 | vals[i] = v; 18 | } 19 | ll sum = accumulate(vals.begin(), vals.end(), 0LL); 20 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,v; 7 | scanf("%d",&n); 8 | vector pos(n); 9 | for(int i=0;i> v; 11 | pos[i] = v; 12 | } 13 | while(scanf("%d",&v) != EOF){ 14 | vector res; 15 | vector guess(n); 16 | guess[v-1] = 0; 17 | for(int i=1;i> v; 19 | guess[v-1] = i; // event i is at v 20 | } 21 | for(int i=0;i 2 | using namespace std; 3 | int main() 4 | { 5 | int t,n,r,u,v,tc=1; 6 | scanf("%d",&t); 7 | while(t--){ 8 | scanf("%d",&n); 9 | vector> floyd(n,vector(n,1e6)); 10 | for(int i=0;i 2 | using namespace std; 3 | 4 | int x,y,d; 5 | 6 | // ax + by = d 7 | // store x, y, and d as global variables 8 | void extendedEuclid(int a, int b) { 9 | if (b == 0) { x = 1; y = 0; d = a; return; } // base case 10 | extendedEuclid(b, a % b); // similar as the original gcd 11 | int x1 = y; 12 | int y1 = x - (a / b) * y; 13 | x = x1; 14 | y = y1; 15 | } 16 | 17 | int main() { 18 | int x1,k,t; 19 | scanf("%d",&t); 20 | while(t--) { 21 | scanf("%d %d",&x1,&k); 22 | int a = x1/k, b = (int)ceil((double)x1/k); 23 | extendedEuclid(a,b); 24 | // ax + by = d 25 | // to get to x1, we multiply whole equation by x1/d 26 | x *= x1/d; 27 | y *= x1/d; 28 | printf("%d %d\n",x,y); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /11933-Splitting Numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | using namespace std; 21 | 22 | int main() { 23 | int v; 24 | while(scanf("%d",&v),v){ 25 | int cnt = 0; 26 | int a = 0, b = 0; 27 | for(int i=0;i<32;i++) 28 | if((v >> i) & 1){ 29 | if(++cnt%2) a |= 1< 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,n,v,tc=1; 7 | cin >> t; 8 | while(t--){ 9 | cin >> n; 10 | vector rungs(1,0); 11 | int maxDiff = 0; 12 | for(int i=0;i> v; 14 | maxDiff = max(maxDiff,v-rungs.back()); 15 | rungs.push_back(v); 16 | } 17 | // answer is either maxDiff or maxDiff+1 18 | int curStrength = maxDiff; 19 | for(int i=1;i curStrength) { 21 | maxDiff++; 22 | break; 23 | } else if(rungs[i]-rungs[i-1] == curStrength){ 24 | curStrength--; 25 | } 26 | printf("Case %d: %d\n",tc++,maxDiff); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /12541-Birthdates.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | using namespace std; 17 | 18 | int main() { 19 | int n, day, month, year; 20 | string name; 21 | scanf("%d\n",&n); 22 | vector, string> > people; 23 | while(n--){ 24 | cin >> name >> day >> month >> year; 25 | people.push_back({make_tuple(year,month,day), name}); 26 | } 27 | sort(people.begin(),people.end()); 28 | cout << people.back().second << endl; 29 | cout << people.front().second << endl; 30 | } 31 | -------------------------------------------------------------------------------- /713-Adding Reversed Numbers.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | int t = sc.nextInt(); 8 | while(t-- > 0){ 9 | StringBuilder a = new StringBuilder(sc.next()); 10 | StringBuilder b = new StringBuilder(sc.next()); 11 | a.reverse(); b.reverse(); 12 | BigInteger res = new BigInteger(a.toString()).add(new BigInteger(b.toString())); 13 | a = new StringBuilder(res.toString()); 14 | a.reverse(); 15 | // remove leading zero 16 | int i=0; 17 | while(i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,m; 7 | bool first = true; 8 | while(scanf("%d %d",&n,&m) != EOF){ 9 | if(!first) printf("\n"); 10 | first = false; 11 | vector> dp(n+1,vector(n+1)); 12 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int t,n,m,v; 6 | scanf("%d",&t); 7 | while(t--){ 8 | scanf("%d %d",&n,&m); 9 | vector dp(m+1); 10 | for(int i=0;i dpNext(m+1,INT_MIN); 12 | for(int j=1;j<=m;j++){ 13 | scanf("%d",&v); 14 | for(int k=m;k>=j && v>=5;k--) 15 | if(dp[k-j] != INT_MIN) 16 | dpNext[k] = max(dp[k-j] + v, dpNext[k]); 17 | } 18 | dp = dpNext; 19 | } 20 | if(dp.back() == INT_MIN) 21 | printf("Peter, you shouldn't have played billiard that much.\n"); 22 | else 23 | printf("Maximal possible average mark - %.2f.\n",(dp.back()+1e-9)/n); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /616-Coconuts, Revisited.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n; 8 | while(scanf("%d",&n),n!=-1){ 9 | bool found = false; 10 | printf("%d coconuts, ",n); 11 | for(int i=sqrt(n)+1; i>1 && !found; i--){ 12 | int remaining = n; 13 | int iteration = 0; 14 | while(iteration != i){ 15 | remaining--; 16 | if(remaining%i != 0) break; // can't split 17 | remaining -= remaining/i; 18 | iteration++; 19 | if(iteration == i && (remaining%i == 0)){ 20 | found = true; 21 | printf("%d people and 1 monkey\n",i); 22 | } 23 | } 24 | } 25 | if(!found) printf("no solution\n"); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /10066-The Twin Towers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int a,b,v,tc=1; 8 | while(scanf("%d %d",&a,&b),(a+b)!=0){ 9 | vector dp(a+1); 10 | vector towerA; 11 | for(int i=0;i dpNext(a+1); 18 | for(int j=0;j 2 | using namespace std; 3 | 4 | int main() { 5 | int t,l,r,p; 6 | string n; 7 | cin >> t; 8 | while(t--){ 9 | vector> vec; 10 | cin >> p; 11 | for(int i=0;i> n >> l >> r; 13 | vec.push_back(make_tuple(n,l,r)); 14 | } 15 | cin >> l; 16 | while(l--){ 17 | cin >> p; 18 | int cnt = 0; 19 | string name; 20 | for(int i=0;i(vec[i]) <= p && get<2>(vec[i]) >= p){ 22 | cnt++; 23 | name = get<0>(vec[i]); 24 | } 25 | cout << (cnt == 1 ? name : "UNDETERMINED") << endl; 26 | } 27 | if(t) cout << endl; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10125-Sumsets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n,v; 8 | while(cin >> n, n){ 9 | bool found = false; 10 | set nums; 11 | for(int i=0;i> v; 13 | nums.insert(v); 14 | } 15 | for(auto d=nums.rbegin();d!=nums.rend() && !found;d++) 16 | for(auto b=nums.rbegin();b!=nums.rend() && !found;b++) 17 | for(auto c=next(b);c!=nums.rend() && !found;c++){ 18 | int a = *d-*b-*c; 19 | if(d == b || d == c) continue; 20 | if(a == *d || a == *b || a == *c) continue; 21 | if(nums.count(a)) { 22 | cout << *d << endl; 23 | found = true; 24 | } 25 | } 26 | if(!found) cout << "no solution" << endl; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /11218-KTV.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,a,b,c,s,tc=1; 6 | while(scanf("%d",&n),n){ 7 | vector> scores; 8 | vector dp(1<<9,-1); 9 | dp[0] = 0; 10 | for(int i=0;i 2 | using namespace std; 3 | 4 | string permute = "ACGT"; 5 | 6 | void dfs(int diff,int k,string& cur, string& ori,vector& res){ 7 | int idx = cur.length(); 8 | if(diff > k) return; 9 | if(idx == ori.length()){ 10 | res.push_back(cur); 11 | return; 12 | } 13 | for(char& c : permute){ 14 | cur += c; 15 | dfs(diff + (c!=ori[idx]),k,cur,ori,res); 16 | cur.pop_back(); 17 | } 18 | } 19 | 20 | int main() 21 | { 22 | int t,n,k; 23 | cin >> t; 24 | while(t--){ 25 | cin >> n >> k; 26 | string in; 27 | cin >> in; 28 | string cur = ""; 29 | vector res; 30 | dfs(0,k,cur,in,res); 31 | cout << res.size() << endl; 32 | for(auto& s : res) 33 | cout << s << endl; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /10910-Marks Distribution.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | // dp to compute number ways to reach value j with i subjects 7 | long long dp[101][101] = {1}; 8 | // for each subject i 9 | for (int i = 1; i <= 100; i++){ 10 | dp[i][0] = 1; 11 | // for each total value j 12 | for (int j = 1; j <= 100; j++) 13 | // we could decide to add 1 to this subject to obtain j (dp[i][j-1]) 14 | // or not add (dp[i-1][j]) 15 | dp[i][j] = dp[i - 1][j] + dp[i][j-1]; 16 | } 17 | int n, t, p, tc; 18 | scanf("%d", &tc); 19 | while (tc--) { 20 | scanf("%d %d %d",&n,&t,&p); 21 | t -= n * p; // start score from zero after subtracting minimum needed score 22 | printf("%lld\n", t >= 0 ? dp[n][t] : 0); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /11100-The Trip, 2007.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,v,tc=0; 7 | while(scanf("%d",&n),n){ 8 | if(tc++) cout << endl; 9 | vector bags; 10 | for(int i=0;i> v; 12 | bags.push_back(v); 13 | } 14 | sort(bags.begin(),bags.end()); 15 | int maxDup = 1; 16 | int cur = 1; 17 | for(int i=1;i 2 | 3 | using namespace std; 4 | int res,best; 5 | void dfs(int i, vector& nums, int sum, int cur, int limit){ 6 | if(sum > limit) return; 7 | else if(sum > best){ 8 | best = sum; 9 | res = cur; 10 | } 11 | if(i >= nums.size()) return; 12 | dfs(i+1,nums,sum+nums[i],cur|(1<> n){ 20 | cin >> s; 21 | vector nums; 22 | for(int i=0;i> v; 24 | nums.push_back(v); 25 | } 26 | res = best = 0; 27 | dfs(0,nums,0,0,n); 28 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int k, n; 6 | 7 | while(scanf("%d %d",&k,&n) == 2){ 8 | vector> dp(n+2, vector(k+2)); 9 | // dp state: count_alpha, last alphabet k (xxxxxk) 10 | for(int i=0;i<=k;i++) dp[1][i] = 1; 11 | for(int i=2;i<=n;i++){ 12 | dp[i][0] = dp[i][k] = dp[i-1][0] + dp[i-1][1]; // first and last digit only have one neighbor (symmetry) 13 | for(int j=1;j 2 | 3 | using namespace std; 4 | 5 | // nim game summary: xor of all piles 6 | // if xor is 0, first player can win, because it is a balanced game 7 | // whenever it is balanced, the player can win 8 | int main() 9 | { 10 | int tc,n,m,r,c; 11 | scanf("%d",&tc); 12 | while(tc--){ 13 | scanf("%d %d %d %d",&m,&n,&r,&c); 14 | // nim game of four piles 15 | // left, right, top, btm of bad piece 16 | int numAbove = r; 17 | int numBelow = m-1-r; 18 | int numLeft = c; 19 | int numRight = n-1-c; 20 | int nimGame = numAbove ^ numBelow ^ numLeft ^ numRight; 21 | if(nimGame == 0) { 22 | printf("Hansel\n"); // hansel start first, so he can win if balanced 23 | } else { 24 | printf("Gretel\n"); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /10858-Unique Factorization.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector*> dfs(int n, int start){ 5 | vector*> res; 6 | for(int i=start;i<=sqrt(n);i++) 7 | if(n%i==0){ 8 | vector*> subRes = dfs(n/i,i); 9 | for(auto& vect : subRes) vect->push_back(i); 10 | res.insert(res.end(),subRes.begin(),subRes.end()); 11 | res.push_back(new vector{n/i,i}); 12 | } 13 | return res; 14 | } 15 | 16 | int main() 17 | { 18 | int n; 19 | while(cin >> n, n){ 20 | vector*> res = dfs(n,2); 21 | cout << res.size() << endl; 22 | for(auto& vect : res){ 23 | for(auto it=vect->rbegin();it!=vect->rend();it++) 24 | cout << *it << (&*it != &vect->front() ? " " : ""); 25 | cout << endl; 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /11057-Exact Sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n,v,t; 8 | while(cin >> n){ 9 | vector books; 10 | for(int i=0;i> v; 12 | books.push_back(v); 13 | } 14 | cin >> t; 15 | 16 | sort(books.begin(),books.end()); 17 | pair res; 18 | auto lo=books.begin(), hi=prev(books.end()); 19 | while(lo t){ 25 | hi--; 26 | } else { 27 | lo++; 28 | } 29 | } 30 | printf("Peter should buy books whose prices are %d and %d.\n\n",res.first,res.second); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /11881-Internal Rate of Return.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | double npv(vector& cfs,double irr){ 5 | double res = 0; 6 | for(auto it=cfs.rbegin();it!=cfs.rend();it++){ 7 | res /= (1.0+irr); 8 | res += *it; 9 | } 10 | return res; 11 | } 12 | 13 | int main() 14 | { 15 | int t,v; 16 | while(scanf("%d",&t),t){ 17 | vector cfs; 18 | for(int i=0;i> v; 20 | cfs.push_back(v); 21 | } 22 | double low=-1,high=10000; 23 | while(high-low>1e-5){ 24 | double mid = (low+high)/2; 25 | double val = npv(cfs,mid); 26 | // higher the irr, the lower the val 27 | if(val>0)low=mid; // make it smaller 28 | else high=mid; 29 | } 30 | printf("%.2f\n",low); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /476-Points in Figures: Rectangles.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void solve() { 5 | char x; 6 | double a,b,c,d; 7 | vector rects; 8 | while(cin >> x, x != '*') { 9 | cin >> a >> b >> c >> d; 10 | rects.emplace_back(a, b, c, d); 11 | } 12 | int idx = 1; 13 | while(cin >> a >> b, a!= 9999.9 || b!=9999.9) { 14 | bool ok = false; 15 | for(int i=0;i z && a < c; 18 | bool withinY = b > v && b < x; 19 | if(withinX && withinY) { 20 | ok = true; 21 | cout << "Point " << idx << " is contained in figure " << (i+1) << "\n"; 22 | } 23 | } 24 | if(!ok) cout << "Point " << idx << " is not contained in any figure\n"; 25 | idx++; 26 | } 27 | 28 | } 29 | 30 | int main() { 31 | int t=1; 32 | while(t--) { 33 | solve(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /10730-Antiarithmetic?.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | int n,v; 10 | 11 | while(scanf("%d:",&n), n){ 12 | vector prev; 13 | unordered_map idxMap; 14 | for(int i=0;i> v; 16 | prev.push_back(v); 17 | idxMap[v] = i; 18 | } 19 | bool hasProgression = false; 20 | for(int i=0;i 9 || !idxMap.count(nextInt)) continue; 25 | if(idxMap[nextInt]>j) hasProgression = true; 26 | } 27 | cout << (hasProgression ? "no" : "yes") << endl; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10892-LCM Cardinality.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int gcd(int a, int b){ 6 | return a==0 ? b : gcd(b%a, a); 7 | } 8 | int lcm(int a, int b){ 9 | return a*(b/gcd(a, b)); 10 | } 11 | 12 | int main() 13 | { 14 | int val; 15 | while(scanf("%d",&val), val!=0){ 16 | vector divisor; 17 | // generate all divisor 18 | for(int i=1;i<=sqrt(val);i++) 19 | if(val%i == 0){ 20 | divisor.push_back(i); 21 | if(val/i != i) divisor.push_back(val/i); 22 | } 23 | // iterate through all pairs of divisor 24 | int res = 0; 25 | for(int i=0;i 2 | using namespace std; 3 | unordered_set visited; 4 | unordered_map> graph; 5 | void dfs(char cur){ 6 | if(visited.count(cur)) return; 7 | visited.insert(cur); 8 | for(char c : graph[cur]) 9 | dfs(c); 10 | } 11 | 12 | int main() { 13 | int t; 14 | char n; 15 | string in; 16 | cin >> t; 17 | while(t--){ 18 | visited.clear(); 19 | graph.clear(); 20 | cin >> n; 21 | cin.ignore(); 22 | while(getline(cin,in), !in.empty()){ 23 | graph[in[0]].insert(in[1]); 24 | graph[in[1]].insert(in[0]); 25 | } 26 | int res = 0; 27 | for(char c='A';c<=n;c++) 28 | if(!visited.count(c)) 29 | dfs(c),res++; 30 | printf("%d\n",res); 31 | if(t) printf("\n"); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /10077-The Stern-Brocot Number System.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int a,b; 7 | pair left,right,mid; 8 | while(scanf("%d %d",&a,&b),!(a==1 && b==1)){ 9 | string res = ""; 10 | left = {0,1}, right = {1,0}, mid = {1,1}; 11 | while(mid.first != a || mid.second != b){ 12 | // avoid floating point calc 13 | int v1 = a*mid.second, v2 = b*mid.first; 14 | if(v1 2 | 3 | using namespace std; 4 | vector primes; 5 | bitset<1000001> isPrime; 6 | void sieve() 7 | { 8 | isPrime.set(); 9 | isPrime[0] = isPrime[1] = 0; 10 | for(long long i=2; i<1000001; i++){ 11 | if(isPrime[i]){ 12 | primes.push_back(i); 13 | for(long long j=i*i; j<1000001; j+=i) 14 | isPrime[j] = 0; 15 | } 16 | } 17 | } 18 | 19 | int main() 20 | { 21 | sieve(); 22 | int in; 23 | while(scanf("%d",&in), in != 0){ 24 | int res = 0; 25 | for(int i=0; i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,m,v; 7 | while(scanf("%d %d",&n,&m),n||m){ 8 | vector dragons; 9 | vector knights; 10 | for(int i=0;i> v; 12 | dragons.push_back(v); 13 | } 14 | for(int i=0;i> v; 16 | knights.push_back(v); 17 | } 18 | sort(dragons.begin(),dragons.end()); 19 | sort(knights.begin(),knights.end()); 20 | int gold=0;int i=0;int j=0; 21 | while(i knights[j] && j 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | while(scanf("%d",&n),n){ 7 | int v; 8 | while(scanf("%d",&v),v){ 9 | stack station; 10 | queue coaches; 11 | coaches.push(v); 12 | int cur = 1; 13 | for(int i=1;i> v; coaches.push(v); 15 | } 16 | while(!coaches.empty()){ 17 | if(station.empty() || station.top() != coaches.front()){ 18 | if(cur > n) break; 19 | station.push(cur++); 20 | } else { 21 | coaches.pop(); 22 | station.pop(); 23 | } 24 | } 25 | cout << (coaches.empty() ? "Yes" : "No") << endl; 26 | } 27 | cout << endl; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10567-Helping Fill Bates.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int q; 7 | string s; 8 | vector> indexes(256); 9 | cin >> s; 10 | for(int i=0;i> q; 13 | while(q--){ 14 | cin >> s; 15 | int prevIndex = -1, from = 0; 16 | bool valid = true; 17 | for(int i=0;i 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,n,m,x,y,v; 8 | cin >> t; 9 | while(t--){ 10 | cin >> n >> m; 11 | vector> graph; 12 | vector dist(n,1e7); 13 | for(int i=0;i> x >> y >> v; 15 | graph.push_back(make_tuple(x,y,v)); 16 | } 17 | dist[0] = 0; 18 | bool hasNeg = false; 19 | for(int i=0;i 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,n,p,q,v,tc=1; 8 | scanf("%d",&t); 9 | while(t--){ 10 | scanf("%d %d %d",&n,&p,&q); 11 | vector lcs; // also lis of position 12 | unordered_map valToPos; // valToPos for the prince 13 | for(int i=0;i<=p;i++){ 14 | scanf("%d",&v); 15 | valToPos[v] = i; 16 | } 17 | for(int i=0;i<=q;i++){ 18 | scanf("%d",&v); 19 | int pos = valToPos[v]; 20 | if(pos == 0) continue; 21 | auto insertion = lower_bound(lcs.begin(),lcs.end(),pos); 22 | // greedy, take lower position 23 | if(insertion == lcs.end()) lcs.push_back(pos); 24 | else *insertion = pos; 25 | } 26 | printf("Case %d: %d\n", tc++, lcs.size()+1); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /10235-Simply Emirp.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.math.BigInteger; 3 | 4 | public class Main { 5 | public static void main(String args[]) { 6 | Scanner sc = new Scanner(System.in); 7 | while(sc.hasNext()){ 8 | int n = sc.nextInt(); 9 | BigInteger val = BigInteger.valueOf(n); 10 | StringBuilder sb = new StringBuilder(String.valueOf(n)).reverse(); 11 | BigInteger reverseVal = new BigInteger(sb.toString()); 12 | System.out.printf("%d is ",n); 13 | // miller-rabin probabilistic prime testing 14 | if(!val.isProbablePrime(10)) 15 | System.out.println("not prime."); 16 | else if(!val.equals(reverseVal) && reverseVal.isProbablePrime(10)) 17 | System.out.println("emirp."); 18 | else 19 | System.out.println("prime."); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /10344-23 out of 5.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool dfs(vector& nums, int cur, vector& used, bool first){ 5 | bool allUsed = true; 6 | for(int i=0;i<5;i++){ 7 | if(used[i]) continue; 8 | allUsed = false; 9 | used[i] = true; 10 | if(dfs(nums,cur+nums[i],used,false)) return true; 11 | else if(!first && dfs(nums,cur-nums[i],used,false)) return true; 12 | else if(!first && dfs(nums,cur*nums[i],used,false)) return true; 13 | used[i] = false; 14 | } 15 | if(allUsed) return cur == 23; 16 | else return false; 17 | } 18 | 19 | int main() 20 | { 21 | int a,b,c,d,e; 22 | while(scanf("%d %d %d %d %d",&a,&b,&c,&d,&e),a||b||c||d||e){ 23 | vector nums = {a,b,c,d,e}; 24 | vector used(5); 25 | cout << (dfs(nums,0,used,true) ? "Possible" : "Impossible") << endl; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /1062-Containers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | // can be solved using greedy or dp (LIS) 4 | int main() { 5 | string in; 6 | int cases = 1; 7 | while(cin >> in, in != "end"){ 8 | // greedy choose the stack with smallest character that is >= than current 9 | vector containers; 10 | for(int i=0;i= in[i] && containers[j] < best){ 15 | pos = j; 16 | best = containers[j]; 17 | } 18 | // need new stack 19 | if(pos == containers.size()) containers.push_back(in[i]); 20 | else containers[pos] = in[i]; 21 | } 22 | printf("Case %d: %d\n",cases++,containers.size()); 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /10617-Again Palindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t; 7 | string in; 8 | scanf("%d\n",&t); 9 | while(t--){ 10 | getline(cin,in); 11 | vector> dp(in.length(),vector(in.length())); 12 | for(int i=0;i=0;start--){ 14 | for(int end=start+1;end 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main() { 18 | int t,v; 19 | cin >> t; 20 | while(t--){ 21 | set> vals; 22 | while(cin >> v, v){ 23 | vals.insert(v); 24 | } 25 | long long total = 0; 26 | int i=1; 27 | for(auto it=vals.begin();it!=vals.end();it++){ 28 | total += pow(*it,i++); 29 | } 30 | total *=2; 31 | if(total > 5000000) 32 | cout << "Too expensive" << endl; 33 | else 34 | cout << total << endl; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /10227-Forest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string setToString(set& set){ 5 | string res = ""; 6 | for(auto it=set.begin(); it!=set.end();it++) 7 | res += to_string(*it) + ":"; 8 | return res; 9 | } 10 | 11 | int main() { 12 | int t,i,j,p,q; 13 | string in; 14 | scanf("%d\n\n",&t); 15 | while(t--){ 16 | unordered_set opinions; 17 | scanf("%d %d\n",&p,&q); 18 | vector> heard(p, set()); 19 | while(getline(cin,in),!in.empty()){ 20 | istringstream iss(in); 21 | iss >> i >> j; 22 | heard[i-1].insert(j); 23 | } 24 | for(auto& vec: heard){ 25 | string str = setToString(vec); 26 | opinions.insert(str); 27 | } 28 | cout << opinions.size() << endl; 29 | if(t) cout << endl; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /11753-Creating Palindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | int tc=1; 8 | void solve() { 9 | int n, k; 10 | cin >> n >> k; 11 | vector seq(n); 12 | for(int i=0;i> seq[i]; 13 | 14 | function go = [&](int l, int r, int c) { 15 | if(c>k) return n+1; 16 | else if(l>=r) return c; 17 | if(seq[l] == seq[r]) return go(l+1, r-1, c); 18 | return min(go(l+1,r,c+1), go(l,r-1,c+1)); 19 | }; 20 | 21 | int diff = go(0, n-1, 0); 22 | cout << "Case " << tc++ << ": "; 23 | if(diff==0) cout << "Too easy\n"; 24 | else if(diff>k) cout << "Too difficult\n"; 25 | else cout << diff << "\n"; 26 | } 27 | 28 | 29 | int main() { 30 | int t=1; 31 | cin >> t; 32 | while(t--) { 33 | solve(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /12346-Water Gate Management.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n,f,c; 8 | cin >> n; 9 | vector> gates; 10 | for(int i=0;i> f >> c; 12 | gates.push_back({f,c}); 13 | } 14 | int tc = 1, t; 15 | cin >> t; 16 | while(t--){ 17 | int best = INT_MAX; 18 | cin >> f >> c; 19 | for(int i=0;i<(1< f) 28 | best = min(best,cost); 29 | } 30 | if(best == INT_MAX) printf("Case %d: IMPOSSIBLE\n",tc++); 31 | else printf("Case %d: %d\n",tc++,best); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /10128-Queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | // use 20 because test queries contains > 13 7 | long long dp[20][20][20]; 8 | memset(dp,0,sizeof(dp)); 9 | dp[1][1][1] = 1; // dp[N][P][R] 10 | // assume we are choosing the spot of the shortest person 11 | // he has to be in the next front, next back, or any middle spot 12 | for(int N=2;N<14;N++) 13 | for(int P=1;P<=N;P++) 14 | for(int R=1;R<=N;R++){ 15 | // choose any spot not at either end, there are N-2 positions 16 | long long middle = dp[N-1][P][R]*(N-2); 17 | // either end 18 | long long front = dp[N-1][P-1][R]; 19 | long long back = dp[N-1][P][R-1]; 20 | dp[N][P][R] = middle+front+back; 21 | } 22 | int t,n,p,r; 23 | cin >> t; 24 | while(t--){ 25 | cin >> n >> p >> r; 26 | printf("%lld\n", dp[n][p][r]); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /11053-Flavius Josephus Reloaded.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | #define ll long long 5 | 6 | ll n, a, b; 7 | 8 | ll f(ll x) { 9 | return (a*(x*x%n)+b)%n; 10 | } 11 | 12 | pair floydCycleFinding(ll x) { 13 | ll tortoise = f(x), hare = f(f(x)); 14 | while(tortoise != hare) { 15 | tortoise = f(tortoise), hare = f(f(hare)); 16 | } 17 | ll mu=0; hare=x; 18 | while(tortoise != hare) { 19 | tortoise = f(tortoise), hare = f(hare); 20 | mu++; 21 | } 22 | ll lambda = 1; hare = f(tortoise); 23 | while(tortoise != hare) { 24 | hare = f(hare); 25 | lambda++; 26 | } 27 | return make_pair(mu, lambda); 28 | } 29 | 30 | 31 | int main() 32 | { 33 | while(scanf("%lld",&n),n){ 34 | scanf("%lld %lld",&a,&b); 35 | pair res = floydCycleFinding(0); 36 | printf("%lld\n",n-res.second); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /11173-Grey Codes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | using namespace std; 20 | 21 | int main() { 22 | int t, a, k; 23 | scanf("%d",&t); 24 | while(t--){ 25 | cin >> a >> k; 26 | // conversion from binary to gray code is simply k^(k>>1) 27 | cout << (k^(k>>1)) << endl; 28 | } 29 | } 30 | // additional 31 | // convert gray code back to binary position 32 | // num = num ^ (num >> 16); 33 | // num = num ^ (num >> 8); 34 | // num = num ^ (num >> 4); 35 | // num = num ^ (num >> 2); 36 | // num = num ^ (num >> 1); 37 | -------------------------------------------------------------------------------- /10706-Number Sequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | string sequence = ""; // store single sequence 7 | int totalLength=0; // length from 1 to n 8 | vector lens(1,0); // cumulative length of concat seq 9 | for(int i=1;i<35000;i++){ 10 | int length = (int)log10(i)+1; 11 | totalLength += length; 12 | sequence += to_string(i); 13 | lens.push_back(totalLength+lens.back()); 14 | } 15 | 16 | int t,v; 17 | cin >> t; 18 | while(t--){ 19 | cin >> v; 20 | int low = 0, high = 34999; 21 | // bisect right to find next smaller sequence 22 | while(low= v) high = mid-1; 25 | else low = mid; 26 | } 27 | // n-th digit in sequence 28 | printf("%c\n", sequence[v-lens[high]-1]); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /10325-The Lottery.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | 9 | ll lcm(ll a, ll b) { 10 | return a*(b/__gcd(a,b)); 11 | } 12 | 13 | ll cntDiv(ll x, ll d) { 14 | return x/d; 15 | } 16 | 17 | void solve() { 18 | ll n, m; 19 | while(cin >> n >> m) { 20 | vector nums(m); 21 | for(int i=0;i> nums[i]; 22 | ll totalDiv = 0; 23 | // PIE 24 | for(int i=1;i<(1< 2 | using namespace std; 3 | 4 | int p,q,r,s,t,u; 5 | 6 | double f(double mid){ 7 | return p*exp(-mid)+q*sin(mid)+r*cos(mid)+s*tan(mid)+t*mid*mid+u; 8 | } 9 | 10 | int main() { 11 | while(scanf("%d %d %d %d %d %d",&p,&q,&r,&s,&t,&u) != EOF){ 12 | // Given f(x) = 0: 13 | // Since f is a non-increasing function on [0,1], 14 | // it is sufficient to check the signs for f(0) and f(1) to determine whether 15 | // there is a root in range [0,1]. 16 | if(f(0)*f(1) > 0) printf("No solution\n"); 17 | else { 18 | double lo = 0, hi = 1; 19 | while((hi-lo) > 0.0000001){ 20 | double mid = (lo+hi)/2; 21 | double val = f(mid); 22 | // raising x, decreases our val 23 | if(val > 0) lo = mid; 24 | else hi = mid; 25 | } 26 | printf("%.4f\n",lo); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /11959-Dice.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t; 8 | string a,b; 9 | cin >> t; 10 | while(t--){ 11 | bool valid = false; 12 | cin >> a >> b; 13 | // front shift y-axis 14 | for(int i=0;i<4 && !valid;i++){ 15 | char tmp = a[0]; 16 | a[0]=a[4];a[4]=a[1];a[1]=a[2];a[2]=tmp; 17 | // left shift x-axis 18 | for(int j=0;j<4 && !valid;j++){ 19 | tmp=a[2]; 20 | a[2]=a[5];a[5]=a[4];a[4]=a[3];a[3]=tmp; 21 | // z-axis shift left turn 22 | for(int k=0;k<4 && !valid;k++){ 23 | tmp=a[0]; 24 | a[0]=a[5];a[5]=a[1];a[1]=a[3];a[3]=tmp; 25 | if(a==b) valid = true; 26 | } 27 | } 28 | } 29 | cout << (valid ? "Equal" : "Not Equal") << endl; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /10608-Friends.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int groupSize[30000]; 5 | int highest; 6 | 7 | int udfsFind(int* udfs, int n){ 8 | return udfs[n] == n ? n : udfsFind(udfs,udfs[n]); 9 | } 10 | 11 | void udfsJoin(int* udfs, int a, int b){ 12 | if(udfsFind(udfs,a) == udfsFind(udfs,b)) return; 13 | int newSize = groupSize[udfsFind(udfs,a)] += groupSize[udfsFind(udfs,b)]; 14 | highest = max(newSize,highest); 15 | udfs[udfsFind(udfs,b)] = udfsFind(udfs,a); 16 | } 17 | 18 | int main() { 19 | int t,n,m,a,b; 20 | cin >> t; 21 | while(t--){ 22 | cin >> n >> m; 23 | highest = 1; 24 | int udfs[n]; 25 | for(int i=0;i> a >> b; 31 | udfsJoin(udfs,a-1,b-1); 32 | } 33 | cout << highest << endl; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /11396-Claw Decomposition.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n,a,b; 4 | vector> graph; 5 | vector colors; 6 | 7 | bool dfs(int cur,int color){ 8 | if(colors[cur] != 0) return colors[cur] == color; 9 | colors[cur] = color; 10 | for(auto& neigh : graph[cur]){ 11 | if(!dfs(neigh,-color)) return false; 12 | } 13 | return true; 14 | } 15 | 16 | int main() 17 | { 18 | while(scanf("%d",&n),n){ 19 | graph.assign(n+1,vector()); 20 | colors.assign(n+1,0); 21 | while(scanf("%d %d",&a,&b),(a+b)!=0){ 22 | graph[a].push_back(b); 23 | graph[b].push_back(a); 24 | } 25 | bool bipartile = true; 26 | for(int i=1;i<=n && bipartile;i++) 27 | if(colors[i] == 0){ 28 | bipartile = dfs(i,1); 29 | } 30 | if(bipartile) printf("YES\n"); 31 | else printf("NO\n"); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /378-Intersecting Lines.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(2); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | void solve() { 8 | int x1,y1,x2,y2,x3,y3,x4,y4; 9 | cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4; 10 | 11 | int a1 = y2-y1; 12 | int b1 = x1 -x2; 13 | int c1 = y1*x2 - x1*y2; 14 | int a2 = y4 -y3; 15 | int b2 = x3 -x4; 16 | int c2 = y3*x4 - x3*y4; 17 | int m = (a1*b2 - b1*a2); 18 | int x = (b1*c2 - b2*c1); 19 | int y = (c1*a2 - c2*a1); 20 | if(m==0) { 21 | if(x||y) cout << "NONE\n"; 22 | else cout << "LINE\n"; 23 | } else { 24 | cout << "POINT " << (double)x/m << " " << (double)y/m << "\n"; 25 | } 26 | } 27 | 28 | int main() { 29 | int t=1; 30 | cin >> t; 31 | cout << "INTERSECTING LINES OUTPUT\n"; 32 | while(t--) { 33 | solve(); 34 | } 35 | cout << "END OF OUTPUT\n"; 36 | } 37 | -------------------------------------------------------------------------------- /10738-Riemann vs Mertens.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | #define N 1000001 5 | #define ll long long 6 | vector numDiffPF; 7 | vector mu; 8 | vector mertens; 9 | 10 | void modifiedSieve(){ 11 | numDiffPF.assign(N, 0); 12 | mu.assign(N, 1); 13 | mertens.assign(N, 0); 14 | mertens[1] = 1; 15 | for(long long i=2;i 2 | using namespace std; 3 | vector dp; 4 | 5 | long long solve(int idx,string& str){ 6 | if(idx==str.length()) return 0; 7 | if(dp[idx] != 0) return dp[idx]; 8 | if(str[idx]=='0') 9 | return dp[idx] = solve(idx+1,str); 10 | else { 11 | long long best = 0; 12 | for(int i=idx;i 2 | using namespace std; 3 | // idea, check if we can do without a certain bit or add a bit 4 | int main() 5 | { 6 | unsigned int m,l,u; 7 | while(scanf("%u %u %u",&m,&l,&u) != EOF){ 8 | unsigned int cur = 0; 9 | for(int i=31;i>=0;i--){ 10 | if(((1<= lower 19 | } 20 | } 21 | cout << cur << endl; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10298-Power Strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | // property of KMP, N - prefixSuffixLen = minimum repeating cycle length 4 | 5 | int kmpPreprocess(string& str){ 6 | int i=0, j=-1; 7 | vector backtable(str.length()+1); 8 | backtable[0] = -1; 9 | while(i= 0 && str[i] != str[j]){ 12 | j = backtable[j]; 13 | } 14 | i++; j++; 15 | backtable[i] = j; 16 | } 17 | return j; // return prefix suffix length 18 | } 19 | 20 | int main() 21 | { 22 | string in; 23 | while(getline(cin,in),in != "."){ 24 | int prefixSuffixLen = kmpPreprocess(in); 25 | int minSeqSize = in.length() - prefixSuffixLen; 26 | if(in.length() % minSeqSize){ 27 | printf("1\n"); 28 | } else 29 | printf("%d\n",in.length()/minSeqSize);//num of repeatition 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /10520-Determine it.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int n,v; 7 | while(scanf("%d %d",&n,&v) != EOF){ 8 | long long a[50][50] = {}; 9 | a[n][1] = v; 10 | for(int i=n; i>= 1; i--){ 11 | for(int j=1; j<=n; j++){ 12 | if(j==1 && i==n) 13 | continue; 14 | if(i>=j){ 15 | long long left = 0, right = 0; 16 | for(int k=i+1;k<=n;k++) 17 | left = max(a[k][1]+a[k][j], left); 18 | for(int k=1;k 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,n,d,v,tc=1; 7 | string in; 8 | cin >> t; 9 | while(t--){ 10 | cin >> n >> d; 11 | vector> stones(1,{true,0}); 12 | int maximum = 0; 13 | for(int i=0;i<=n;i++){ 14 | int loc; 15 | if(i> in; 17 | loc = stoi(in.substr(2)); 18 | } else loc = d; 19 | // compare with previous stone if last one is a big 20 | // compare with i-2 stone if last one is a small (we can ignore previous stone since it is the min or used) 21 | int distToPrev = loc - (stones.back().first ? stones.back().second : stones[stones.size()-2].second); 22 | maximum = max(distToPrev,maximum); 23 | stones.push_back({in[0]=='B',loc}); 24 | } 25 | printf("Case %d: %d\n",tc++,maximum); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /154-Recycling.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string in; 6 | while(getline(cin,in), in != "#"){ 7 | // count schemes 8 | unordered_map cntMap; 9 | vector scheme; 10 | int res = 0; 11 | int best = INT_MAX; 12 | do{ 13 | scheme.push_back(in); 14 | istringstream iss(in); 15 | while(getline(iss,in,',')) cntMap[in]++; 16 | }while(getline(cin,in), in[0] != 'e'); 17 | 18 | for(int i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | using namespace std; 20 | 21 | int main() { 22 | int n; 23 | while(cin >> n, n){ 24 | list deck; 25 | for(int i=n;i>0;i--) deck.push_back(i); 26 | cout << "Discarded cards:"; 27 | while(deck.size() > 1){ 28 | cout << " " << deck.back(); 29 | deck.pop_back(); 30 | if(deck.size() > 1) cout << ","; 31 | deck.push_front(deck.back()); deck.pop_back(); 32 | } 33 | cout << endl << "Remaining card: " << deck.front() << endl; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /11059-Maximum Product.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // O(N) dynamic programming 6 | // track largest negative number and cumulative product 7 | 8 | int main() 9 | { 10 | int n,v; 11 | int cases = 1; 12 | while(scanf("%d",&n) != EOF){ 13 | long long largestNeg = 0; 14 | long long dpProd = 1; 15 | long long res = 0; 16 | for(int i=0;i> v; 18 | dpProd *= v; 19 | if(dpProd == 0){ 20 | largestNeg = 0; 21 | dpProd = 1; 22 | } else if(dpProd > 0){ 23 | res = max(res,dpProd); 24 | } else { 25 | if(largestNeg) res = max(res,dpProd/largestNeg); 26 | else largestNeg = dpProd; 27 | largestNeg = max(largestNeg,dpProd); 28 | } 29 | } 30 | printf("Case #%d: The maximum product is %lld.\n\n",cases++,res); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /11133-Eigensequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int f,l; 5 | int memo[45][45]; 6 | 7 | int solve(int low, int high){ 8 | if(low == high) return 1; 9 | else if(low > high) return 0; 10 | if(memo[low][high] != -1) return memo[low][high]; 11 | int res = 0; 12 | for(int m=low+1;m<=high;m++){ 13 | int diff = m-low; 14 | // longer method if a1 = low, a2 = m, can we form a1 using the diff? 15 | // int times = ceil((double)low/diff); 16 | // if(times*diff == low){ 17 | // res += solve(m,high); 18 | // } 19 | // actually just need to check for divisibility, definitely can form a1 20 | if((low%diff) == 0) 21 | res += solve(m, high); 22 | } 23 | return memo[low][high] = res; 24 | } 25 | 26 | int main() { 27 | while(scanf("%d %d",&f,&l), f 2 | using namespace std; 3 | #define ll long long 4 | 5 | int d,g,tc=1; 6 | // state: first project left, second project left, cur project 7 | ll memo[34][34][2]; 8 | 9 | ll solve(int p1, int p2, int cur) { 10 | if(p1 == 0) { 11 | return cur == 1; 12 | } else if(p2 == 0) return 0; // p1 have to finish first 13 | ll &res = memo[p1][p2][cur]; 14 | if(res != -1) return res; 15 | res = 0; 16 | for(int i=1;i<=g && i<=(cur?p2:p1);i++) { 17 | if(cur == 0) 18 | res += solve(p1 - i, p2, cur^1); 19 | else 20 | res += solve(p1, p2 - i, cur^1); 21 | } 22 | return res; 23 | } 24 | 25 | int main() { 26 | while(scanf("%d %d",&d,&g), (d+g) != -2){ 27 | memset(memo, -1, sizeof memo); 28 | ll res = (g==0 || d==0) ? 0 : solve(d,d,0)*2; // multiply 2, for each starting project (symmetry) 29 | printf("Case %d: %lld\n", tc++, res); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /11690-Money Matters.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int owe[10000]; 5 | int udfs[10000]; 6 | 7 | int udfsFind(int n){ 8 | return udfs[n] == n ? n : udfsFind(udfs[n]); 9 | } 10 | 11 | void udfsJoin(int a, int b){ 12 | if(udfsFind(a) == udfsFind(b)) return; 13 | owe[udfsFind(a)] += owe[udfsFind(b)]; 14 | udfs[udfsFind(b)] = udfsFind(a); 15 | } 16 | 17 | int main() { 18 | int t; 19 | int n,m; 20 | int v,b; 21 | cin >> t; 22 | while(t--){ 23 | cin >> n >> m; 24 | for(int i=0;i> v; 27 | owe[i] = v; 28 | } 29 | while(m--){ 30 | cin >> v >> b; 31 | udfsJoin(v,b); 32 | } 33 | bool res = true; 34 | for(int i=0;i 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | typedef long long ll; 8 | typedef pair ii; 9 | #define fi first 10 | #define se second 11 | #define sz(x) (int((x).size())) 12 | #define all(x) (x).begin(), (x).end() 13 | #define rall(x) (x).rbegin(), (x).rend() 14 | 15 | void solve() { 16 | int n; 17 | while(cin >> n, n) { 18 | vector pts(n); 19 | for(int i=0;i> pts[i].fi >> pts[i].se; 20 | auto [mx, my] = pts[n/2]; 21 | int a = 0, b = 0; 22 | for(auto&[x, y] : pts) { 23 | if(x == mx || y == my) continue; 24 | bool left = x < mx; 25 | bool btm = y < my; 26 | if(left == btm) a++; 27 | else b++; 28 | } 29 | cout << a << " " << b << "\n"; 30 | } 31 | } 32 | 33 | int main() { 34 | int t=1; 35 | while(t--) { 36 | solve(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /10742-The New Rule in Euphomia.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | vector sieve(int n){ 5 | bitset<1000001> isPrime; 6 | isPrime.set(); 7 | vector res; 8 | for(long long i=2;i<=n;i++) 9 | if(isPrime[i]){ 10 | res.push_back(i); 11 | for(long long j=i*i;j<=n;j+=i) isPrime[j] = false; 12 | } 13 | return res; 14 | } 15 | 16 | int main() 17 | { 18 | vector primes = sieve(1000000); 19 | int n, tc=1; 20 | while(cin >> n, n){ 21 | int lo = 0; 22 | int hi = lower_bound(primes.begin(),primes.end(),n) - primes.begin(); 23 | // two pointer 24 | int res = 0; 25 | while(lo 2 | using namespace std; 3 | 4 | const string vowels = "AUEOI"; 5 | const string consonants = "JSBKTCLDMVNWFXGPYHQZR"; 6 | 7 | int main() { 8 | int t,n,tc=1; 9 | cin >> t; 10 | while(t--){ 11 | cin >> n; 12 | string selectedVowels = ""; 13 | string selectedConsonants = ""; 14 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int p,g,t; 6 | string name, in; 7 | double v; 8 | scanf("%d %d",&p,&g); 9 | unordered_map votes; 10 | 11 | for(int i=0;i> name >> v; 13 | votes[name] = v*10; 14 | } 15 | for(int i=1;i<=g;i++){ 16 | cin >> name; 17 | double total = votes[name]; 18 | while(cin >> in, in == "+"){ 19 | cin >> name; 20 | total += votes[name]; 21 | } 22 | cin >> t; 23 | t *= 10; 24 | cout << "Guess #" << i << " was "; 25 | bool eval = true; 26 | if(in == "<") eval = total < t; 27 | else if(in == "<=") eval = total <= t; 28 | else if(in == ">") eval = total > t; 29 | else if(in == ">=") eval = total >= t; 30 | else eval = total == t; 31 | cout << (eval ? "correct." : "incorrect.") << endl; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /331-Mapping the Swaps.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int res; 4 | int least; 5 | 6 | void dfs(int cnt,vector& vec){ 7 | bool sorted = true; 8 | for(int i=1;i 0; 20 | least = cnt; 21 | } 22 | } 23 | } 24 | 25 | int main() 26 | { 27 | int n,v; 28 | int tc=1; 29 | while(cin >> n,n){ 30 | vector vec; 31 | for(int i=0;i> v; 33 | vec.push_back(v); 34 | } 35 | res = 0, least = INT_MAX; 36 | dfs(0,vec); 37 | printf("There are %d swap maps for input data set %d.\n",res,tc++); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /10680-LCM.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define N 1000001 4 | 5 | 6 | int main() { 7 | bitset isPrime; 8 | isPrime.set(); 9 | isPrime[0] = isPrime[1] = false; 10 | vector basePrime(N,1); 11 | 12 | // sieve 13 | for(long long i=2;i dp(N); 24 | dp[1] = 1; 25 | for(int i=2;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int k,n,m,v; 7 | string in; 8 | cin >> k; 9 | while(k--){ 10 | cin >> n >> m; 11 | cin.ignore(); 12 | vector> sets; 13 | for(int i=0;i s; 17 | while(iss >> v) s.push_back(v-1); 18 | sets.push_back(s); 19 | } 20 | bool found = false; 21 | for(int i=0;i<(1< 2 | 3 | using namespace std; 4 | 5 | int computeSimilarity(string& a, string& b){ 6 | int best = 0; 7 | for(int i=0;i+b.size() <= a.size();i++){ 8 | int match = 0; 9 | for(int j=0;j movies; 22 | scanf("%d %d\n",&m,&q); 23 | while(m--){ 24 | cin >> in; 25 | movies.push_back(in); 26 | } 27 | for(int i=0;i> in; 29 | int best = 0; 30 | int idx = 1; 31 | for(int j=0;j best){ 34 | best = sim; 35 | idx = j+1; 36 | } 37 | } 38 | cout << idx << endl; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /1362-Exploring Pyramids.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | int __fastio = fastio(); 5 | 6 | 7 | typedef long long ll; 8 | constexpr ll mod = 1e9; 9 | int main(){ 10 | string s; 11 | while(cin >> s) { 12 | int n = s.size(); 13 | vector> dp(n, vector(n)); 14 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int b,r,v,tc=1; 7 | cin >> b; 8 | while(b--){ 9 | cin >> r; 10 | int bestFrom = 0, bestTo = 0, best = 0; 11 | int curFrom = 0, cur = 0; 12 | for(int i=1;i> v; 14 | cur += v; 15 | // reset cur if fall below 0 16 | if(cur<0){ 17 | curFrom = i; 18 | cur = 0; 19 | } 20 | // update best if higher or have larger index distance 21 | if(cur>best || (cur == best && (i-curFrom) > (bestTo-bestFrom))){ 22 | bestFrom = curFrom; 23 | bestTo = i; 24 | best = cur; 25 | } 26 | } 27 | if(best == 0) printf("Route %d has no nice parts\n",tc++); 28 | else 29 | printf("The nicest part of route %d is between stops %d and %d\n",tc++,bestFrom+1,bestTo+1); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /543-Goldbach's Conjecture.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | vector primes; 5 | bitset<1000001> isPrime; 6 | void sieve() 7 | { 8 | isPrime.set(); 9 | isPrime[0] = isPrime[1] = 0; 10 | for(long long i=2; i<1000001; i++){ 11 | if(isPrime[i]){ 12 | primes.push_back(i); 13 | for(long long j=i*i; j<1000001; j+=i) 14 | isPrime[j] = 0; 15 | } 16 | } 17 | } 18 | 19 | int main() 20 | { 21 | sieve(); 22 | int in; 23 | while(scanf("%d",&in), in != 0){ 24 | bool found = false; 25 | for(int i=0; i 2 | using namespace std; 3 | 4 | unordered_map pars; 5 | unordered_map groupSize; 6 | int best; 7 | 8 | string udfsFind(string& n){ 9 | return pars[n] == n ? n : pars[n] = udfsFind(pars[n]); 10 | } 11 | 12 | void join(string& a, string& b){ 13 | string parA = udfsFind(a); 14 | string parB = udfsFind(b); 15 | if(parA == parB) return; 16 | groupSize[parA] += groupSize[parB]; 17 | best = max(best, groupSize[parA]); 18 | pars[parB] = parA; 19 | } 20 | 21 | int main() 22 | { 23 | int c,r; 24 | string a,b; 25 | while(scanf("%d %d",&c,&r),c||r){ 26 | pars.clear(); 27 | groupSize.clear(); 28 | best = 1; 29 | for(int i=0;i> a; 31 | pars[a] = a; 32 | groupSize[a] = 1; 33 | } 34 | for(int i=0;i> a >> b; 36 | join(a,b); 37 | } 38 | cout << best << endl; 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /11348-Exhibition.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t, p, n, v; 6 | int cases = 1; 7 | scanf("%d",&t); 8 | while(t--){ 9 | cin >> p; 10 | unordered_map> stampOwner; 11 | vector res(p,0); 12 | for(int i=0;i> n; 14 | while(n--){ 15 | cin >> v; 16 | if(!stampOwner.count(v)) stampOwner[v] = unordered_set(); 17 | stampOwner[v].insert(i); 18 | } 19 | } 20 | int totalUnique = 0; 21 | for(auto& p : stampOwner){ 22 | if(p.second.size() == 1) { 23 | totalUnique++; 24 | res[*p.second.begin()]++; 25 | } 26 | } 27 | cout << "Case " << cases++ << ":"; 28 | for(auto& d : res) 29 | cout << " " << setprecision(6) << fixed << d*100.0/totalUnique << "%"; 30 | cout << endl; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /11953-Battleships.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int t,n,tc=1; 4 | string in; 5 | vector grid; 6 | vector> dirs = {{1,0},{0,1},{-1,0},{0,-1}}; 7 | 8 | void floodfill(int x,int y){ 9 | if(x<0||y<0||x>=n||y>=n) return; 10 | if(grid[x][y] != '@' && grid[x][y] != 'x') return; 11 | grid[x][y] = '-'; 12 | for(auto& dir : dirs){ 13 | int nxtX = x+dir[0]; 14 | int nxtY = y+dir[1]; 15 | floodfill(nxtX,nxtY); 16 | } 17 | } 18 | 19 | int main() 20 | { 21 | cin >> t; 22 | while(t--){ 23 | cin >> n; 24 | grid.clear(); 25 | for(int i=0;i> in; 27 | grid.push_back(in); 28 | } 29 | int res = 0; 30 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | bool notfirst = false; 7 | while(scanf("%d",&n),n){ 8 | if(notfirst) cout << endl; 9 | notfirst = true; 10 | bool found = false; 11 | for(int fghij = 1234; fghij <= 98765 / n; fghij++ ) { 12 | int abcde = fghij * n; 13 | int tmp, used = (fghij < 10000); // leading zero, set bit 14 | tmp = abcde; 15 | while(tmp){ 16 | used |= 1 << (tmp % 10); 17 | tmp /= 10; 18 | } 19 | tmp = fghij; 20 | while(tmp){ 21 | used |= 1 << (tmp % 10); 22 | tmp /= 10; 23 | } 24 | if(used == (1<<10)-1){ 25 | printf("%0.5d / %0.5d = %d\n",abcde,fghij,n); 26 | found = true; 27 | } 28 | } 29 | if(!found) 30 | printf("There are no solutions for %d.\n",n); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /10305-Ordering Tasks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | int n,m,a,b; 4 | vector visited; 5 | unordered_map> graph; 6 | 7 | void dfs(int cur,stack& topo){ 8 | visited[cur] = true; 9 | for(auto& successor : graph[cur]) 10 | if(!visited[successor]) 11 | dfs(successor,topo); 12 | topo.push(cur); 13 | } 14 | 15 | int main() 16 | { 17 | while(scanf("%d %d",&n,&m),(n+m)!=0){ 18 | visited.assign(n+1,false); 19 | graph.clear(); 20 | for(int i=0;i> a >> b; 22 | graph[a].insert(b); 23 | } 24 | stack topological; 25 | for(int i=1;i<=n;i++) 26 | if(!visited[i]) 27 | dfs(i,topological); 28 | while(!topological.empty()){ 29 | printf("%d",topological.top()); 30 | topological.pop(); 31 | if(topological.empty()) printf("\n"); 32 | else printf(" "); 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /10534-Wavio Sequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void lis(vector& nums,vector& dp){ 5 | vector LIS; 6 | for(int i=0;i dp,dp_reverse; 19 | vector nums; 20 | while(n--){ 21 | scanf("%d",&v); 22 | nums.push_back(v); 23 | } 24 | 25 | lis(nums,dp); 26 | reverse(nums.begin(),nums.end()); 27 | lis(nums,dp_reverse); 28 | 29 | int res = 1; 30 | for(int i=0;i 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int a,b,tc=1; 8 | while(scanf("%d %d",&a,&b),(a+b)!=0){ 9 | vector> graph(101,vector(101,1e6)); 10 | int maxN = 1; 11 | do { 12 | maxN = max(maxN,max(a,b)); 13 | graph[a][b] = 1; 14 | } while(scanf("%d %d",&a,&b), (a+b)!=0); 15 | 16 | // floyd-warshall 17 | for(int k=1;k<=maxN;k++) 18 | for(int i=1;i<=maxN;i++) 19 | for(int j=1;j<=maxN;j++) 20 | graph[i][j] = min(graph[i][j],graph[i][k]+graph[k][j]); 21 | 22 | int sum=0,cnt=0; 23 | for(int i=1;i<=maxN;i++) 24 | for(int j=1;j<=maxN;j++) 25 | if(i!=j && graph[i][j] < 1e6){ 26 | cnt++; 27 | sum+=graph[i][j]; 28 | } 29 | 30 | printf("Case %d: average length between pages = %.3f clicks\n",tc++, (double)sum/cnt); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /102-Ecological Bin Packing.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int b[3]; 6 | int g[3]; 7 | int c[3]; 8 | while(scanf("%d %d %d %d %d %d %d %d %d", 9 | b,g,c,b+1,g+1,c+1,b+2,g+2,c+2) != EOF){ 10 | string cur = "BCG"; 11 | string best = "ZZZ"; 12 | int bestCnt = INT_MAX; 13 | // BCG 14 | do{ 15 | int cost = 0; 16 | for(int i=0;i<3;i++){ 17 | for(int j=0;j<3;j++){ 18 | if(i==j) continue; 19 | if(cur[i] == 'B') cost += b[j]; 20 | else if(cur[i] == 'C') cost += c[j]; 21 | else if(cur[i] == 'G') cost += g[j]; 22 | } 23 | } 24 | if(cost < bestCnt) { 25 | bestCnt = cost; 26 | best = cur; 27 | } 28 | }while(next_permutation(cur.begin(),cur.end())); 29 | 30 | cout << best << " " << bestCnt << endl; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /10895-Matrix Transpose.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int m,n; 6 | int s,v; 7 | while(scanf("%d %d",&m,&n) != EOF){ 8 | vector>> transpose(n,vector>()); 9 | for(int i=0;i> s; 11 | vector pos; 12 | for(int j=0;j> v; 14 | pos.push_back(v-1); 15 | } 16 | for(int j=0;j> v; 18 | transpose[pos[j]].push_back({v,i+1}); 19 | } 20 | } 21 | printf("%d %d\n",n,m); 22 | for(int i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main() { 18 | int t; 19 | int cases = 1; 20 | cin >> t; 21 | int t1,t2,f,a,c1,c2,c3; 22 | while(t--){ 23 | cin >> t1 >> t2 >> f >> a >> c1 >> c2 >> c3; 24 | vector classScore = {c1,c2,c3}; 25 | sort(classScore.begin(),classScore.end()); 26 | int total = t1+t2+f+a+(classScore[1] + classScore[2])/2; 27 | char grade; 28 | if(total>=90) grade = 'A'; 29 | else if(total>=80) grade = 'B'; 30 | else if(total>=70) grade = 'C'; 31 | else if(total>=60) grade = 'D'; 32 | else grade = 'F'; 33 | printf("Case %d: %c\n",cases++,grade); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /12321-Gas Stations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int len,g,p,r; 6 | while(scanf("%d %d",&len,&g),len||g){ 7 | vector> intervals; 8 | for(int i=0;i cur) { 17 | break; 18 | } 19 | int furthestRight = intervals[i].second; 20 | while(i+1 2 | using namespace std; 3 | 4 | int udfsFind(int* udfs, int n){ 5 | return udfs[n] == n ? n : udfs[n] = udfsFind(udfs,udfs[n]); 6 | } 7 | 8 | void udfsJoin(int* udfs, int a, int b) { 9 | int par_a = udfsFind(udfs,a), par_b = udfsFind(udfs,b); 10 | udfs[par_a] = par_b; 11 | } 12 | 13 | int main() { 14 | int t,n,a,b; 15 | char c; 16 | string in; 17 | scanf("%d\n",&t); 18 | while(t--){ 19 | scanf("%d\n",&n); 20 | int success = 0, fail = 0; 21 | int udfs[n+1]; 22 | for(int i=1;i<=n;i++) udfs[i]=i; 23 | while(getline(cin,in),!in.empty()){ 24 | istringstream iss(in); 25 | iss >> c >> a >> b; 26 | if(c == 'c') udfsJoin(udfs,a,b); 27 | else if(udfsFind(udfs,a) == udfsFind(udfs,b)) 28 | success++; 29 | else 30 | fail++; 31 | } 32 | printf("%d,%d\n",success,fail); 33 | if(t) cout << endl; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /855-Lunch in Grid City.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main(){ 18 | int t; 19 | scanf("%d",&t); 20 | while(t--){ 21 | int a,b,c,d,e; 22 | scanf("%d %d %d",&a,&b,&c); 23 | vector xCoord; 24 | vector yCoord; 25 | int n = c; 26 | while(c--){ 27 | scanf("%d %d",&d,&e); 28 | xCoord.push_back(d); 29 | yCoord.push_back(e); 30 | } 31 | // greedy, choose median to minimize error 32 | sort(xCoord.begin(),xCoord.end()); 33 | sort(yCoord.begin(),yCoord.end()); 34 | n -= (n%2 == 0); 35 | printf("(Street: %d, Avenue: %d)\n",xCoord[n/2],yCoord[n/2]); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /352-The Seasonal War.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | vector> dirs = {{0,1},{1,0},{1,1},{-1,0},{0,-1},{-1,-1},{1,-1},{-1,1}}; 5 | 6 | void dfs(int x,int y,vector& grid){ 7 | if(x<0||y<0||x>=grid.size()||y>=grid.size()) return; 8 | if(grid[x][y] != '1') return; 9 | grid[x][y] = '0'; 10 | for(auto& dir : dirs){ 11 | int nextX = x+dir[0]; 12 | int nextY = y+dir[1]; 13 | dfs(nextX,nextY,grid); 14 | } 15 | } 16 | 17 | int main() 18 | { 19 | int n,tc=1; 20 | string in; 21 | while(cin >> n){ 22 | vector grid; 23 | for(int i=0;i> in; 25 | grid.push_back(in); 26 | } 27 | int res = 0; 28 | for(int i=0;i 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | int main() { 18 | int t, v; 19 | int r, c, m, n; 20 | int k = 1; 21 | string in; 22 | scanf("%d\n",&t); 23 | while(t--){ 24 | scanf("%d %d %d %d\n",&r,&c,&m,&n); 25 | int best = 0; 26 | vector cnt(26,0); 27 | for(int i=0;i 2 | 3 | using namespace std; 4 | 5 | vector> dirs = {{-1,-1},{-1,0},{0,-1},{0,1},{1,0},{1,1}}; 6 | vector grid; 7 | int n; 8 | 9 | bool dfs(int x,int y,char c){ 10 | if(x<0||x>=n||y<0||y>=n) return false; 11 | if(grid[x][y] != c) return false; 12 | if(c=='w' && y==n-1) return true; 13 | if(c=='b' && x==n-1) return true; 14 | grid[x][y] = '-'; 15 | for(auto& dir : dirs){ 16 | int nextX = x+dir[0]; 17 | int nextY = y+dir[1]; 18 | if(dfs(nextX,nextY,c)) return true; 19 | } 20 | return false; 21 | } 22 | 23 | int main() { 24 | string in; int tc=1; 25 | while(scanf("%d",&n),n!=0){ 26 | grid.clear(); 27 | for(int i=0;i> in; 29 | grid.push_back(in); 30 | } 31 | bool blackWon = false; 32 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() { 5 | int tc=1,c,s,v; 6 | while(scanf("%d %d",&c,&s) != EOF){ 7 | // dummy specimens, assign 2 to each chamber 8 | vector specimens(2*c); 9 | int total = 0; 10 | for(int i=0;i> v; 12 | specimens[i] = v; 13 | total += v; 14 | } 15 | double avg = (double)total/c, imbalance = 0; 16 | sort(specimens.begin(),specimens.end()); 17 | printf("Set #%d\n",tc++); 18 | for(int i=0;i 2 | using namespace std; 3 | 4 | vector songs; 5 | int tc,n,t,m; 6 | char c; 7 | // state: diskIdx,remainingTime,diskLeft 8 | vector>> memo; 9 | 10 | int solve(int idx, int time, int disk) { 11 | if(disk == 0 || idx == songs.size()) return 0; 12 | if(memo[idx][time][disk] != -1) return memo[idx][time][disk]; 13 | int best = solve(idx+1, time, disk); 14 | best = max(best, solve(idx, t, disk-1)); 15 | if(time >= songs[idx]) { 16 | best = max(best, solve(idx+1, time-songs[idx], disk) + 1); 17 | } 18 | return memo[idx][time][disk] = best; 19 | } 20 | 21 | int main() { 22 | scanf("%d",&tc); 23 | while(tc--){ 24 | scanf("%d %d %d",&n,&t,&m); 25 | songs.assign(n,0); 26 | memo.assign(n,vector>(t+1,vector(m+1,-1))); 27 | for(int i=0;i 2 | using namespace std; 3 | int fastio() { ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); return 0; } 4 | 5 | int __fastio = fastio(); 6 | 7 | 8 | constexpr int N = 101; 9 | double pascal[N][N]; // n choose k 10 | void initPascal() { 11 | for(int i=0;i> m >> w >> c, (m+w)) { 22 | double res = 0; 23 | double woman = (double)w/(m+w); 24 | double man = 1 - woman; 25 | for(int i=0;i<=c;i+=2) { 26 | int count_woman = c - i; 27 | double prob = pow(woman, count_woman) * pow(man, i); // * note one person is allowed to receive more than once 28 | double ways = pascal[c][i]; // ways to select i candies from c 29 | res += prob*ways; 30 | } 31 | cout << res << "\n"; 32 | } 33 | } 34 | 35 | int main() { 36 | initPascal(); 37 | solve(); 38 | } 39 | -------------------------------------------------------------------------------- /10029-Edit Step Ladders.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | map dp; 7 | int res=0; 8 | string in; 9 | while (cin >> in) 10 | { 11 | int len=1; 12 | for(int i=0;i<=in.size();i++){ 13 | // delete 14 | string edit(in); 15 | edit.erase(i, 1); 16 | if(dp.count(edit)) len=max(len, dp[edit]+1); 17 | for(char c ='a';c<='z';c++) 18 | { 19 | // insert 20 | edit = in; 21 | edit.insert(i,1,c); 22 | 23 | if(edit 2 | using namespace std; 3 | 4 | vector> boxes; 5 | vector> dp; 6 | int n,wt,load; 7 | 8 | int knapsack(int idx, int remainingWeight){ 9 | if(idx == n || remainingWeight == 0) return 0; 10 | if(dp[idx][remainingWeight] != -1) return dp[idx][remainingWeight]; 11 | dp[idx][remainingWeight] = knapsack(idx+1,remainingWeight); 12 | if(remainingWeight >= boxes[idx].first){ 13 | int limit = min(remainingWeight-boxes[idx].first,boxes[idx].second); 14 | dp[idx][remainingWeight] = max(dp[idx][remainingWeight], 15 | knapsack(idx+1,limit)+1); 16 | } 17 | return dp[idx][remainingWeight]; 18 | } 19 | 20 | int main() 21 | { 22 | while(cin >> n,n){ 23 | boxes.clear(); 24 | for(int i=0;i> wt >> load; 26 | boxes.push_back({wt,load}); 27 | } 28 | dp = vector>(n,vector(6001,-1)); 29 | printf("%d\n",knapsack(0,6000)); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /11988-Broken Keyboard (a.k.a. Beiju Text).cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | using namespace std; 17 | 18 | 19 | int main() { 20 | string in; 21 | while(getline(cin,in), !in.empty()){ 22 | list listing; 23 | string cur = ""; 24 | bool infront = false; 25 | for(char& c : in){ 26 | if(c != '[' && c != ']') cur += c; 27 | if(c == '[' || c == ']' || &c == &in.back()){ 28 | if(infront) listing.push_front(cur); 29 | else listing.push_back(cur); 30 | cur = ""; 31 | infront = c == '['; 32 | } 33 | } 34 | for(string& str : listing) cout << str; 35 | cout << endl; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /10130-SuperSale.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int t,n,v,q; 5 | int memo[1010][40]; 6 | int value[1010]; 7 | int weight[1010]; 8 | 9 | int bestValue(int idx, int weightLeft){ 10 | if (idx == n || weightLeft == 0) return 0; 11 | if(memo[idx][weightLeft] != -1) return memo[idx][weightLeft]; 12 | // cannot fit this item 13 | if(weight[idx] > weightLeft) 14 | return memo[idx][weightLeft] = bestValue(idx+1,weightLeft); 15 | return memo[idx][weightLeft] = max( 16 | bestValue(idx+1,weightLeft), 17 | value[idx]+bestValue(idx+1,weightLeft-weight[idx])); 18 | } 19 | 20 | int main() 21 | { 22 | scanf("%d",&t); 23 | while(t--){ 24 | memset(memo,-1,sizeof(memo)); 25 | scanf("%d",&n); 26 | for(int i=0;i 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | int main() { 15 | int n,m,v; 16 | while(scanf("%d %d\n",&n,&m),n){ 17 | vector> vals; 18 | for(int i=0;i&a,tuple&b){ 23 | if(get<2>(a) != get<2>(b)) return get<2>(a) < get<2>(b); 24 | if(get<1>(a) && get<1>(b)) return get<0>(a) < get<0>(b); 25 | if(!get<1>(a) && !get<1>(b)) return get<0>(a) > get<0>(b); 26 | return !get<1>(a); 27 | }); 28 | printf("%d %d\n",n,m); 29 | for(auto& p : vals) 30 | cout << get<0>(p) << endl; 31 | } 32 | printf("0 0\n"); 33 | } 34 | -------------------------------------------------------------------------------- /11548-Blackboard Bonanza.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int compute(const string& a, const string& b){ 6 | int best = 0; 7 | // imagine b shifting 8 | // -b.length()+1 to a.length()+b.length()-2 9 | int i = -b.length()+1; 10 | for(; i<(int)(a.length()+b.length()-1);i++){ 11 | int cand = 0; 12 | for(int j=0;j=a.length()) continue; 14 | if(a[i+j] == b[j]) cand++; 15 | } 16 | best = max(best,cand); 17 | } 18 | return best; 19 | } 20 | 21 | int main() 22 | { 23 | int t,n; 24 | string in; 25 | cin >> t; 26 | while(t--){ 27 | int res = 0; 28 | cin >> n; 29 | vector words; 30 | for(int i=0;i> in; 32 | words.push_back(in); 33 | } 34 | for(int i=0;i 2 | using namespace std; 3 | 4 | // idea: twice the initial length of matrix to handle wrap-around 5 | 6 | int main() 7 | { 8 | int t,n; 9 | cin >> t; 10 | while(t--){ 11 | cin >> n; 12 | vector> dp(n*2+1,vector(n*2+1)); 13 | for(int i=1;i<=n;i++){ 14 | for(int j=1;j<=n;j++){ 15 | scanf("%d",&dp[i][j]); 16 | dp[i][j+n] = dp[i+n][j] = dp[i+n][j+n] = dp[i][j]; 17 | } 18 | } 19 | // running sum 20 | for(int i=1;i<=2*n;i++) 21 | for(int j=1;j<=2*n;j++){ 22 | dp[i][j] += (dp[i][j-1]+dp[i-1][j]-dp[i-1][j-1]); 23 | } 24 | // dp 25 | int res = INT_MIN; 26 | for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) 27 | for(int k=i;k 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int t,p,n,v; 8 | cin >> t; 9 | while(t--){ 10 | cin >> p >> n; 11 | vector symbols; 12 | for(int i=0;i> v; 16 | symbol = (symbol<<1)+v; 17 | } 18 | symbols.push_back(symbol); 19 | } 20 | int least = INT_MAX; 21 | for(int i=0;i<(1< represents; 23 | for(auto& symbol : symbols) 24 | represents.insert(i&symbol); 25 | if(represents.size() == n){ 26 | int numBits = 0; 27 | v = i; 28 | while(v){ 29 | numBits++; 30 | v &= (v-1); 31 | } 32 | least = min(least, numBits); 33 | } 34 | } 35 | cout << least << endl; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /882-The Mailbox Manufacturers Problem.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | #define N 11 5 | #define M 101 6 | 7 | // state, n mailboxes, low, high 8 | int dp[N][M][M]; 9 | int main(){ 10 | for (int i=0;i 2 | 3 | // complete search between 2 coord O(O*T), nums of one and three 4 | using namespace std; 5 | 6 | int main() 7 | { 8 | int M; 9 | char cells[101][101]; 10 | 11 | while(scanf("%d",&M) != EOF){ 12 | for(int i=0;i> ones; 15 | vector> threes; 16 | 17 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main() 5 | { 6 | int t,dist,v; 7 | cin >> t; 8 | while(t--){ 9 | cin >> dist; 10 | dist/=100; 11 | deque> wind; 12 | for(int i=0;i<10;i++){ 13 | vector row; 14 | for(int j=0;j> v; 16 | row.push_back(v); 17 | } 18 | wind.push_front(row); 19 | } 20 | vector dp(10,1e7); 21 | dp[0] = 0; 22 | for(int i=0;i dpNext(10,0); 24 | for(int j=0;j<10;j++){ 25 | int fromBelow = j==0 ? 1e7 : (dp[j-1] + 60 - wind[j-1][i]); 26 | int fromAbove = j==9 ? 1e7 : (dp[j+1] + 20 - wind[j+1][i]); 27 | int stay = dp[j] + 30 - wind[j][i]; 28 | dpNext[j] = min(stay, min(fromBelow, fromAbove)); 29 | } 30 | dp = dpNext; 31 | } 32 | printf("%d\n\n",dp[0]); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /1197-The Suspects.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int udfsFind(int*group,int n){ 5 | return group[n] == n ? n : group[n] = udfsFind(group,group[n]); 6 | } 7 | 8 | void udfsJoin(int*group,int a,int b,vector& groupSize){ 9 | int parA = udfsFind(group,a); 10 | int parB = udfsFind(group,b); 11 | if(parA == parB) return; 12 | group[parB] = parA; 13 | groupSize[parA] += groupSize[parB]; 14 | } 15 | 16 | int main() { 17 | int n,m,v; 18 | int s; 19 | while(scanf("%d %d",&n,&m),n){ 20 | int group[n] = {}; 21 | vector groupSize(n,1); 22 | for(int i=0;i> s; 25 | int prev = -1; 26 | while(s--){ 27 | cin >> v; 28 | if(prev != -1) udfsJoin(group,prev,v,groupSize); 29 | prev = v; 30 | } 31 | } 32 | v = udfsFind(group,0); 33 | cout << groupSize[v] << endl; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /1241-Jollybee Tournament.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | using namespace std; 17 | 18 | int main() 19 | { 20 | int t,n,m,v; 21 | scanf("%d",&t); 22 | while(t--){ 23 | scanf("%d %d",&n,&m); 24 | int nums = pow(2,n); 25 | bitset<1024> bits; 26 | bits.set(); 27 | while(m--){ 28 | cin >> v; 29 | bits.reset(v-1); 30 | } 31 | int res = 0; 32 | while(nums){ 33 | int idx = 0; 34 | for(int i=1;i>= 1; 39 | } 40 | cout << res << endl; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /188-Perfect Hash.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int indexStr(string& s){ 5 | int v = 0; 6 | for(char c : s) 7 | v = (v<<5) + (c-'a'+1); 8 | return v; 9 | } 10 | 11 | int main() { 12 | string str,in; 13 | while(getline(cin,str)){ 14 | vector indexes; 15 | istringstream iss(str); 16 | while(iss >> in) indexes.push_back(indexStr(in)); 17 | 18 | int C = 0, n = indexes.size(); 19 | bool valid = false; 20 | while(!valid){ 21 | valid = true; 22 | for(int i=0;i 2 | using namespace std; 3 | 4 | // or use lower_bound function 5 | // bisect_left allow us to find the first leftmost insertion spot 6 | int bisect_left(vector& marb, int target){ 7 | int low = 0; 8 | int high = marb.size()-1; 9 | while(low marb[mid]) low = mid+1; 12 | else high = mid; 13 | } 14 | return low; 15 | } 16 | 17 | int main() 18 | { 19 | int n,q,v,tc=1; 20 | pair left,right,mid; 21 | while(scanf("%d %d",&n,&q),n||q){ 22 | vector marb; 23 | for(int i=0;i> v; 25 | marb.push_back(v); 26 | } 27 | sort(marb.begin(),marb.end()); 28 | printf("CASE# %d:\n",tc++); 29 | while(q--){ 30 | cin >> v; 31 | int pos = bisect_left(marb,v); 32 | if(marb[pos] == v) printf("%d found at %d\n",v,pos+1); 33 | else printf("%d not found\n",v); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /10487-Closest Sums.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n,m,v; 6 | int cases = 1; 7 | while(scanf("%d",&n),n){ 8 | vector vals; 9 | while(n--){ 10 | cin >> v; 11 | vals.push_back(v); 12 | } 13 | vector sum; 14 | for(int i=0;i> m; 19 | printf("Case %d:\n",cases++); 20 | while(m--){ 21 | cin >> v; 22 | auto upper = lower_bound(sum.begin(),sum.end(),v); 23 | auto lower = lower_bound(sum.begin(),sum.end(),v); 24 | if(lower != sum.begin()) --lower; 25 | int res; 26 | if(upper==sum.end()) res = *lower; 27 | else 28 | res = abs(v-*lower) < abs(v-*upper) ? *lower : *upper; 29 | printf("Closest sum to %d is %d.\n",v,res); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /501-Black Box.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | // Log(N) per operation using multiset 4 | // alternative: use a maxHeap & minHeap 5 | // maxHeap of size i, where top item is our result 6 | 7 | int main() { 8 | int k,m,n,v; 9 | scanf("%d\n",&k); 10 | while(k--){ 11 | cin >> m >> n; 12 | multiset sorted; 13 | vector items; 14 | while(m--){ 15 | cin >> v; 16 | items.push_back(v); 17 | } 18 | auto it = items.begin(); 19 | auto sortedIt = sorted.begin(); 20 | while(n--){ 21 | cin >> v; 22 | while(sorted.size() *it) sortedIt--; 27 | it++; 28 | } 29 | cout << *sortedIt++ << endl; 30 | } 31 | if(k) cout< 2 | using namespace std; 3 | 4 | bool can(vector& vessels, int cap, int m){ 5 | int remain = cap; 6 | for(auto& milk : vessels){ 7 | // milk will overflow max cap? 8 | if(milk > cap) return false; 9 | if(milk > remain) { 10 | // use next container 11 | if(--m == 0) return false; 12 | remain = cap; 13 | } 14 | remain -= milk; 15 | } 16 | return true; 17 | } 18 | 19 | int main() 20 | { 21 | int n,m,v; 22 | while(scanf("%d %d",&n,&m) != EOF){ 23 | vector vessels; 24 | int lo,hi=0; 25 | for(int i=0;i> v; 27 | vessels.push_back(v); 28 | hi += v; 29 | } 30 | lo = hi/vessels.size(); 31 | // lower_bound (bisect-left) 32 | while(lo 2 | using namespace std; 3 | 4 | int main() { 5 | int n,t,b; 6 | while(scanf("%d",&n),n){ 7 | vector> trips; 8 | for(int i=0;i dp(n+1,1e7); 13 | dp[0] = 0; 14 | for(int i=0;i next_dp(n+1,1e7); 17 | for(int j=0;j<=n;j++){ 18 | int sphere_left = min(j+b,n); 19 | int no_use = dp[j] + t; 20 | next_dp[sphere_left] = min(next_dp[sphere_left], no_use); 21 | if(j>0){ 22 | int use = dp[j] + t/2; 23 | sphere_left = min(j+b-1,n); 24 | next_dp[sphere_left] = min(next_dp[sphere_left], use); 25 | } 26 | } 27 | dp = next_dp; 28 | } 29 | printf("%d\n",*min_element(dp.begin(), dp.end())); 30 | } 31 | } 32 | --------------------------------------------------------------------------------