Problem p02696 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <stack>
#include <string>
#include <tgmath.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define rep(i, b, e) for (i = b; i < e; ++i)
#define repr(i, b, e) for (i = b; i >= e; --i)
#define ull unsigned long long int
#define ll long long int
#define pint pair<int, int>

#define M_DEBUG 1
#define PI 3.141592653589793

#define E '\\n'

#define printt(x) cout << (x) << endl;
#define printa(x, n)                                                           \\
  for (int i = 0; i < n; i++) {                                                \\
    cout << (x[i]) << "\\n";                                                    \\
  }
#define INF (1e18)

const ll MAX = 1000000000;
const ll MOD = 1e9 + 7;

ll a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;

template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

ll aabs(ll a) {
  if (a < 0)
    return -a;
  return a;
}

// fast power
ll calc(ll a, ll b) {
  if (b == 0)
    return 1;
  else if (b % 2 == 0) {
    ll d = calc(a, b / 2);
    return (d * d) % MOD;
  } else
    return (a * calc(a, b - 1)) % MOD;
}

// fast combination
ll comb(ll n, ll a) {
  ll b = 1, c = 1;
  for (ll i = 1; i <= a; ++i) {
    b = b * i % MOD;
    c = c * (n - i + 1) % MOD;
  }

  return c * calc(b, MOD - 2) % MOD;
}

ll comb2(ll a) {
  ll b = a / 2;
  if (a % 2) {
    b = (a - 1) / 2;
    return (b * a);
  }
  return (b * (a - 1));
}

int dfs(int x, int y, int z) {
  if (x == a && y == b && z == c)
    return 1;

  int ans = 0;
  if (x != a)
    ans += dfs(x + 1, y, z);
  if (x >= y + 1 /* && y != b*/)
    ans += dfs(x, y + 1, z);
  if (y >= z + 1 /* && z != c*/)
    ans += dfs(x, y, z + 1);

  return ans;
}

uint64_t gcd_impl(uint64_t n, uint64_t m) {
  for (int i = 0; i < 10; ++i) {
    uint64_t t = n - m;
    bool q = m > t;
    n = q ? m : t;
    m = q ? t : m;
    if (m == 0) {
      return n;
    }
  }
  return gcd_impl(m, n % m);
}

uint64_t gcd(uint64_t n, uint64_t m) {
  return n > m ? gcd_impl(n, m) : gcd_impl(m, n);
}

const int INF_ = 1e+7;

// 0-indexed

struct Node {
  std::vector<int> nodes;
  std::vector<int> edge_costs;

  int num = 0;
  int cost = INF_;
  int link_out = 0;
  int link_in = 0;
  int pcost = 0;
};

class Graph {
public:
  Graph(int n, bool directed);
  ~Graph();

  void setGraph(int n, int node, int edge_cost);
  void Dijkstra(int start);
  void print();
  std::vector<int> topologicalSort();

  int longestPath();

  int ans = 0;

private:
  std::vector<Node> m_graph;
  int m_size;
  bool m_directed = false;
};

Graph::Graph(int n, bool directed) : m_size(n), m_directed(directed) {
  m_graph = std::vector<Node>(m_size);
}

Graph::~Graph() {}

void Graph::setGraph(int n, int node, int edge_cost) {
  --n;
  --node;
  ++m_graph[node].link_in;
  m_graph[n].nodes.emplace_back(node);
  m_graph[n].edge_costs.emplace_back(edge_cost);
  ++m_graph[n].link_out;
}

void Graph::Dijkstra(int start) {
  m_graph[start].cost = 0;
  std::queue<int> q;
  q.push(start);
  while (!q.empty()) {
    int qi = q.front();
    q.pop();

    for (int i = 0; i < m_graph[qi].nodes.size(); ++i) {
      int qqi = m_graph[qi].nodes[i],
          new_cost = m_graph[qi].edge_costs[i] + m_graph[qi].cost;
      if (m_graph[qqi].cost > new_cost) {
        m_graph[qqi].cost = new_cost;
        q.push(qqi);
      }
    }
  }
}

int Graph::longestPath() {
  int mx = 0;
  for (auto &&g : m_graph) {
    if (g.pcost > mx)
      mx = g.pcost;
  }
  return mx;
}

void Graph::print() {
  for (int i = 0; i < m_size; ++i) {
    std::cout << i + 1 << " : ";
    for (int j = 0; j < m_graph[i].nodes.size(); ++j)
      std::cout << m_graph[i].nodes[j] + 1 << ", ";
    std::cout << std::endl;
  }

  for (int i = 0; i < m_size; ++i)
    std::cout << i + 1 << " : " << m_graph[i].link_in << ", "
              << m_graph[i].link_out << std::endl;
}

std::vector<int> Graph::topologicalSort() {
  std::queue<int> q;
  for (int i = 0; i < m_size; ++i)
    if (m_graph[i].link_in == 0) {
      q.push(i);
      m_graph[i].pcost = 1;
    }

  std::vector<int> topo;
  std::vector<int> tmp(m_size);
  for (int i = 0; i < m_size; ++i)
    tmp[i] = m_graph[i].link_in;

  while (!q.empty()) {

    int i = q.front();
    q.pop();
    topo.emplace_back(i);

    for (auto &&j : m_graph[i].nodes) {
      m_graph[j].link_in--;
      if (m_graph[j].link_in == 0) {
        q.push(j);
        m_graph[j].pcost = m_graph[i].pcost + 1;
      }
    }
  }

  for (int i = 0; i < m_size; ++i)
    m_graph[i].link_in = tmp[i];

  return topo;
}

struct HashPair {

  // 注意 constがいる
  template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {

    // first分をハッシュ化する
    auto hash1 = hash<T1>{}(p.first);

    // second分をハッシュ化する
    auto hash2 = hash<T2>{}(p.second);

    // 重複しないようにハッシュ処理
    size_t seed = 0;
    seed ^= hash1 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    seed ^= hash2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    return seed;
  }
};

int main(void) {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  /*
  cin >> n >> m >> q;

  vector<vector<ll> > vv(q, vector<ll>(4, 0));
  rep (i, 0, q) {
      cin >> vv[i][0] >> vv[i][1] >> vv[i][2] >> vv[i][3];
  }
*/

  cin >> a >> b >> n;

  if (n >= b)
    x = b - 1;
  else
    x = n;

  c = floor((double)a / (double)b * x);
  d = floor((double)x / (double)b) * a;

  cout << c - d << endl;

  return 0;
}


Error: TLE

Fixed submission:

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <stack>
#include <string>
#include <tgmath.h>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define rep(i, b, e) for (i = b; i < e; ++i)
#define repr(i, b, e) for (i = b; i >= e; --i)
#define ull unsigned long long int
#define ll long long int
#define pint pair<int, int>

#define M_DEBUG 1
#define PI 3.141592653589793

#define E '\\n'

#define printt(x) cout << (x) << endl;
#define printa(x, n)                                                           \\
  for (int i = 0; i < n; i++) {                                                \\
    cout << (x[i]) << "\\n";                                                    \\
  }
#define INF (1e18)

const ll MAX = 1000000000;
const ll MOD = 1e9 + 7;

ll a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z;

template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

ll aabs(ll a) {
  if (a < 0)
    return -a;
  return a;
}

// fast power
ll calc(ll a, ll b) {
  if (b == 0)
    return 1;
  else if (b % 2 == 0) {
    ll d = calc(a, b / 2);
    return (d * d) % MOD;
  } else
    return (a * calc(a, b - 1)) % MOD;
}

// fast combination
ll comb(ll n, ll a) {
  ll b = 1, c = 1;
  for (ll i = 1; i <= a; ++i) {
    b = b * i % MOD;
    c = c * (n - i + 1) % MOD;
  }

  return c * calc(b, MOD - 2) % MOD;
}

ll comb2(ll a) {
  ll b = a / 2;
  if (a % 2) {
    b = (a - 1) / 2;
    return (b * a);
  }
  return (b * (a - 1));
}

int dfs(int x, int y, int z) {
  if (x == a && y == b && z == c)
    return 1;

  int ans = 0;
  if (x != a)
    ans += dfs(x + 1, y, z);
  if (x >= y + 1 /* && y != b*/)
    ans += dfs(x, y + 1, z);
  if (y >= z + 1 /* && z != c*/)
    ans += dfs(x, y, z + 1);

  return ans;
}

uint64_t gcd_impl(uint64_t n, uint64_t m) {
  for (int i = 0; i < 10; ++i) {
    uint64_t t = n - m;
    bool q = m > t;
    n = q ? m : t;
    m = q ? t : m;
    if (m == 0) {
      return n;
    }
  }
  return gcd_impl(m, n % m);
}

uint64_t gcd(uint64_t n, uint64_t m) {
  return n > m ? gcd_impl(n, m) : gcd_impl(m, n);
}

const int INF_ = 1e+7;

// 0-indexed

struct Node {
  std::vector<int> nodes;
  std::vector<int> edge_costs;

  int num = 0;
  int cost = INF_;
  int link_out = 0;
  int link_in = 0;
  int pcost = 0;
};

class Graph {
public:
  Graph(int n, bool directed);
  ~Graph();

  void setGraph(int n, int node, int edge_cost);
  void Dijkstra(int start);
  void print();
  std::vector<int> topologicalSort();

  int longestPath();

  int ans = 0;

private:
  std::vector<Node> m_graph;
  int m_size;
  bool m_directed = false;
};

Graph::Graph(int n, bool directed) : m_size(n), m_directed(directed) {
  m_graph = std::vector<Node>(m_size);
}

Graph::~Graph() {}

void Graph::setGraph(int n, int node, int edge_cost) {
  --n;
  --node;
  ++m_graph[node].link_in;
  m_graph[n].nodes.emplace_back(node);
  m_graph[n].edge_costs.emplace_back(edge_cost);
  ++m_graph[n].link_out;
}

void Graph::Dijkstra(int start) {
  m_graph[start].cost = 0;
  std::queue<int> q;
  q.push(start);
  while (!q.empty()) {
    int qi = q.front();
    q.pop();

    for (int i = 0; i < m_graph[qi].nodes.size(); ++i) {
      int qqi = m_graph[qi].nodes[i],
          new_cost = m_graph[qi].edge_costs[i] + m_graph[qi].cost;
      if (m_graph[qqi].cost > new_cost) {
        m_graph[qqi].cost = new_cost;
        q.push(qqi);
      }
    }
  }
}

int Graph::longestPath() {
  int mx = 0;
  for (auto &&g : m_graph) {
    if (g.pcost > mx)
      mx = g.pcost;
  }
  return mx;
}

void Graph::print() {
  for (int i = 0; i < m_size; ++i) {
    std::cout << i + 1 << " : ";
    for (int j = 0; j < m_graph[i].nodes.size(); ++j)
      std::cout << m_graph[i].nodes[j] + 1 << ", ";
    std::cout << std::endl;
  }

  for (int i = 0; i < m_size; ++i)
    std::cout << i + 1 << " : " << m_graph[i].link_in << ", "
              << m_graph[i].link_out << std::endl;
}

std::vector<int> Graph::topologicalSort() {
  std::queue<int> q;
  for (int i = 0; i < m_size; ++i)
    if (m_graph[i].link_in == 0) {
      q.push(i);
      m_graph[i].pcost = 1;
    }

  std::vector<int> topo;
  std::vector<int> tmp(m_size);
  for (int i = 0; i < m_size; ++i)
    tmp[i] = m_graph[i].link_in;

  while (!q.empty()) {

    int i = q.front();
    q.pop();
    topo.emplace_back(i);

    for (auto &&j : m_graph[i].nodes) {
      m_graph[j].link_in--;
      if (m_graph[j].link_in == 0) {
        q.push(j);
        m_graph[j].pcost = m_graph[i].pcost + 1;
      }
    }
  }

  for (int i = 0; i < m_size; ++i)
    m_graph[i].link_in = tmp[i];

  return topo;
}

struct HashPair {

  // 注意 constがいる
  template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {

    // first分をハッシュ化する
    auto hash1 = hash<T1>{}(p.first);

    // second分をハッシュ化する
    auto hash2 = hash<T2>{}(p.second);

    // 重複しないようにハッシュ処理
    size_t seed = 0;
    seed ^= hash1 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    seed ^= hash2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    return seed;
  }
};

int main(void) {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  /*
  cin >> n >> m >> q;

  vector<vector<ll> > vv(q, vector<ll>(4, 0));
  rep (i, 0, q) {
      cin >> vv[i][0] >> vv[i][1] >> vv[i][2] >> vv[i][3];
  }
*/

  cin >> a >> b >> n;

  for (x = 0; x <= n; ++x) {
    long long c = floor((double)a / (double)b * x);
    // cout << c << " ";
    long long d = floor((double)x / (double)b) * a;
    // cout << d << endl;
    e = c - d;
    if (e < f)
      break;
    f = e;
  }

  cout << f << endl;

  return 0;
}