ICPC 2012 - L. Takeover Wars
State the problem in your own words. Focus on the mathematical or algorithmic core rather than repeating the full statement.
Source-first archive entry
This page is built from the copied files in competitive_programming/icpc/2012/L-takeover-wars. Edit
competitive_programming/icpc/2012/L-takeover-wars/solution.tex to update the written solution and
competitive_programming/icpc/2012/L-takeover-wars/solution.cpp to update the implementation.
The website does not replace those files with hand-maintained HTML. It reads the copied source tree during the build and exposes the exact files below.
Problem Statement
Copied statement text kept beside the solution archive for direct reference.
Problem L
Takeover Wars
Problem ID: takeover
You are studying a takeover war between two large corporations, Takeover Incorporated and Buyout
Limited. Each of these corporations controls a number of subsidiaries. The aim in this war is simply
to drive the competition out of the market. There are N subsidiaries of Takeover Incorporated and M
subsidiaries of Buyout Limited, and you know the market value of each subsidiary.
Each company can designate one of its subsidiaries to perform a takeover. The takeover can either be
friendly or hostile. A friendly takeover means a subsidiary of a corporation merges with a different
subsidiary of the same corporation. The market value of the merged subsidiary is the sum of the market
values of the constituent subsidiaries. There is no constraint on the relative sizes of the subsidiaries
participating in a friendly takeover.
A hostile takeover means a subsidiary A of a corporation attempts to take over a subsidiary B of the
other corporation. For this to succeed, the market value of A has to be greater than the market value of
B. After this move, B disappears from the market. The market value of A does not change (the gain of
incorporating B’s assets is offset by the monetary cost of the takeover). For simplicity we assume that
no sequence of moves leads to two subsidiaries of different corporations having the same market value.
The companies take turns making moves in this takeover war, with Takeover Incorporated going first.
A company will do nothing on its turn only if it cannot make a takeover. A company loses the takeover
war if all its subsidiaries are taken over.
Your aim is to learn which company can guarantee a victory from this war. In the first case of the
sample data, Takeover Incorporated can simply take over one of the companies of Buyout Limited in
its first move with the 7-value subsidiary. Then it will lose one of its small (1-value) subsidiaries to a
hostile takeover, and then it will take over the second subsidiary of Buyout Limited. In the second case,
Takeover has to make a friendly takeover in its first move. Buyout Limited will join its two subsidiaries
into a single company with market value 10. Takeover will have to make a friendly takeover again
(as again it will not have a large enough subsidiary to take over Buyout’s giant). Now Takeover will
have two subsidiaries, valued either 9 and 3 or 6 and 6. In either case, Buyout takes over one of these
subsidiaries, Takeover has to pass, and Buyout takes over the other one.
Input
Each test case is described by three lines of input. The first line contains two numbers 1 ≤ N ≤ 105 and
1 ≤ M ≤ 105 denoting respectively the number of subsidiaries of Takeover Incorporated and Buyout
Limited. The next line lists the N sizes ai of the subsidiaries of Takeover Incorporated (1 ≤ ai ≤ 1012 ),
and the third line lists the M sizes bj of the subsidiaries of Buyout Limited (1 ≤ bj ≤ 1012 ).
Output
For each test case, display the case number and either the phrase Takeover Incorporated or the
phrase Buyout Limited depending on who wins the takeover war if both corporations act optimally.
Sample Input Output for Sample Input
3 2 Case 1: Takeover Incorporated
7 1 1 Case 2: Buyout Limited
5 5
4 2
3 3 3 3
5 5
Editorial
Rendered from the copied solution.tex file. The original TeX source remains
available below.
Key Observations
Write the structural observations that make the problem tractable.
State any useful invariant, monotonicity property, graph interpretation, or combinatorial reformulation.
If the constraints matter, explain exactly which part of the solution they enable.
Algorithm
Describe the data structures and the state maintained by the algorithm.
Explain the processing order and why it is sufficient.
Mention corner cases explicitly if they affect the implementation.
Correctness Proof
We prove that the algorithm returns the correct answer.
Lemma 1.
State the first key claim.
Proof.
Provide a concise proof.
Lemma 2.
State the next claim if needed.
Proof.
Provide a concise proof.
Theorem.
The algorithm outputs the correct answer for every valid input.
Proof.
Combine the lemmas and finish the argument.
Complexity Analysis
State the running time and memory usage in terms of the input size.
Implementation Notes
Mention any non-obvious implementation detail that is easy to get wrong.
Mention numeric limits, indexing conventions, or tie-breaking rules if relevant.
Code
Exact copied C++ implementation from solution.cpp.
#include <bits/stdc++.h>
using namespace std;
namespace {
void solve() {
// Fill in the full solution logic for the problem here.
}
} // namespace
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
}
Source Files
Exact copied source-of-truth files. Edit solution.tex for the write-up and solution.cpp for the implementation.
\documentclass[11pt]{article}
\usepackage[margin=1in]{geometry}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage{amsmath,amssymb,amsthm}
\usepackage{enumitem}
\title{ICPC World Finals 2012\\L. Takeover Wars}
\author{}
\date{}
\begin{document}
\maketitle
\section*{Problem Summary}
State the problem in your own words. Focus on the mathematical or algorithmic core rather than repeating the full statement.
\section*{Key Observations}
\begin{itemize}[leftmargin=*]
\item Write the structural observations that make the problem tractable.
\item State any useful invariant, monotonicity property, graph interpretation, or combinatorial reformulation.
\item If the constraints matter, explain exactly which part of the solution they enable.
\end{itemize}
\section*{Algorithm}
\begin{enumerate}[leftmargin=*]
\item Describe the data structures and the state maintained by the algorithm.
\item Explain the processing order and why it is sufficient.
\item Mention corner cases explicitly if they affect the implementation.
\end{enumerate}
\section*{Correctness Proof}
We prove that the algorithm returns the correct answer.
\paragraph{Lemma 1.}
State the first key claim.
\paragraph{Proof.}
Provide a concise proof.
\paragraph{Lemma 2.}
State the next claim if needed.
\paragraph{Proof.}
Provide a concise proof.
\paragraph{Theorem.}
The algorithm outputs the correct answer for every valid input.
\paragraph{Proof.}
Combine the lemmas and finish the argument.
\section*{Complexity Analysis}
State the running time and memory usage in terms of the input size.
\section*{Implementation Notes}
\begin{itemize}[leftmargin=*]
\item Mention any non-obvious implementation detail that is easy to get wrong.
\item Mention numeric limits, indexing conventions, or tie-breaking rules if relevant.
\end{itemize}
\end{document}
#include <bits/stdc++.h>
using namespace std;
namespace {
void solve() {
// Fill in the full solution logic for the problem here.
}
} // namespace
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
return 0;
}