ICPC 2013 - C. Surely You Congest
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/2013/C-surely-you-congest. Edit
competitive_programming/icpc/2013/C-surely-you-congest/solution.tex to update the written solution and
competitive_programming/icpc/2013/C-surely-you-congest/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.
ICPC 2013
2013 World Finals
St. Petersburg
HOSTED BY ITMO
Problem C
Surely You Congest
Time Limit: 10 seconds
You are in charge of designing an advanced centralized traffic management system for smart cars. The
goal is to use global information to instruct morning commuters, who must drive downtown from the
suburbs, how best to get to the city center while avoiding traffic jams.
Unfortunately, since commuters know the city and are selfish, you cannot simply tell them to travel
routes that take longer than normal (otherwise they will just ignore your directions). You can only
convince them to change to different routes that are equally fast.
The city’s network of roads consists of intersections that are connected by bidirectional roads of various
travel times. Each commuter starts at some intersection, which may vary from commuter to commuter.
All commuters end their journeys at the same place, which is downtown at intersection 1. If two com-
muters attempt to start travelling along the same road in the same direction at the same time, there will be
congestion; you must avoid this. However, it is fine if two commuters pass through the same intersection
simultaneously or if they take the same road starting at different times.
Determine the maximum number of commuters who can drive downtown without congestion, subject
to all commuters starting their journeys at exactly the same time and without any of them taking a
suboptimal route.
Figure C.1: Illustration of Sample Input 2.
In Figure C.1, cars are shown in their original locations. One car is already downtown. Of the cars at in-
tersection 4, one can go along the dotted route through intersection 3, and another along the dashed route
through intersection 2. But the remaining two cars cannot reach downtown while avoiding congestion.
So a maximum of 3 cars can reach downtown with no congestion.
Input
The input consists of a single test case. The first line contains three integers n, m, and c, where n
(1 ≤ n ≤ 25 000) is the number of intersections, m (0 ≤ m ≤ 50 000) is the number of roads, and c
(0 ≤ c ≤ 1 000) is the number of commuters. Each of the next m lines contains three integers xi , yi , and
ti describing one road, where xi and yi (1 ≤ xi , yi ≤ n) are the distinct intersections the road connects,
and ti (1 ≤ ti ≤ 10 000) is the time it takes to travel along that road in either direction. You may assume
ICPC 2013
2013 World Finals
St. Petersburg
HOSTED BY ITMO
that downtown is reachable from every intersection. The last line contains c integers listing the starting
intersections of the commuters.
Output
Display the maximum number of commuters who can reach downtown without congestion.
Sample Input 1 Sample Output 1
3 3 2 2
1 2 42
2 3 1
2 3 1
2 3
Sample Input 2 Sample Output 2
4 4 5 3
1 2 5
1 3 4
4 2 5
4 3 6
4 4 4 4 1
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 2013\\C. Surely You Congest Time Limit: 10 seconds}
\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;
}