//2021 RoboCom 世界机器人开发者大赛-本科组（初赛）
//7-1懂的都懂
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 55, M = 210;
unordered_set<int>s;
int a[N], b[M];
bool st[N];
void dfs(int c, int num)
{
    if (c == 4)
    {
        if (num % 4 == 0)
        {
            s.insert(num / 4);
            return;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        if (!st[i])
        {
            st[i] = true;//找数时防止搜重
            dfs(c + 1, num + a[i]);
            st[i] = false;//搜完一个数 回复现场 下一个数可以再用
        }
    }
}
int main()
{
    cin >> n >> k;
    for (int i = 1; i <= n; i++)cin >> a[i];
    dfs(0, 0);
    while (k--)
    {
        int m;
        cin >> m;
        bool ok = 1;
        for (int i = 1; i <= m; i++)
        {
            int x;
            cin >> x;
            if (s.count(x) == 0)ok = 0;
        }
        if (ok)cout << "Yes" << endl;
        else cout << "No" << endl;
    }
    return 0;
}

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_set>
#include<vector>
using namespace std;
const int N = 55, M = 255 * 4;
int n, m, k, x;
int num[N];
bool st[M];
vector<int> a;
unordered_set<int> s;
void init()
{
    for (int a = 0; a < n; a++)
    {
        for (int b = a + 1; b < n; b++)
        {
            for (int c = b + 1; c < n; c++)
            {
                for (int d = c + 1; d < n; d++)
                    //                  s.insert(num[a] + num[b] + num[c] + num[d]);
                    st[num[a] + num[b] + num[c] + num[d]] = true;
            }
        }
    }
}
bool judge()
{
    for (int& x : a)
        //      if(s.count(x * 4) == 0)
        if (!st[x * 4])
            return false;
    return true;
}
int main()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        cin >> num[i];
    init();
    while (m--)
    {
        cin >> k;
        a.clear();
        a.resize(k);
        for (int i = 0; i < k; i++)
            cin >> a[i];
        judge() ? puts("Yes") : puts("No");
    }
    return 0;
}*/
//7-2芬兰木棋

#include <bits/stdc++.h>
//>1的单独拿 =1且在同一方向的一起拿
using namespace std;
struct node
{
    int x, y, v;
    bool operator < (const node& W) const
    {
        return (x != W.x && x < W.x) || (y != W.y && y < W.y);
    }
};
int n;
const int N = 1e5 + 10;
map<double, vector<node>>mp;
int sum, cnt;
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        int x, y, s;
        cin >> x >> y >> s;
        sum += s;
        double k = y * 1.0 / x;
        mp[k].push_back({ x,y,s });
    }
    for (auto t : mp)
    {
        auto vc = t.second;
        sort(vc.begin(), vc.end());//按离原点的距离排序
        int flag = 0;
        for (auto tt : vc)
        {
            if (tt.v != 1 && flag == 0)cnt++;//比1大且前面没有1单独拿
            if (tt.v != 1 && flag != 0)//比1大且前面有1次数加2
            {
                flag = 0;
                cnt += 2;
            }
            if (tt.v == 1)//为1时标记
            {
                flag++;
            }
        }
        if (flag)cnt++;//可能有1在后面
    }
    cout << sum << " " << cnt;
    return 0;
}

//7-3 打怪升级 
#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
const int inf = 1e9 + 10;
const int maxn = 1010;
int e[maxn][maxn];
struct edge { int to, w1, w2; };
vector<edge>G[maxn];
struct node {
    int u, w1, w2;
    bool operator < (const node& b)const { return w1 != b.w1 ? w1 > b.w1 : w2 < b.w2; }
};
int dist[maxn], dist2[maxn], vis[maxn], pre[maxn];
void dfs(int x) {
    if (pre[x] == -1)return;
    dfs(pre[x]);
    cout << "->" << x;
}
int main() {
    memset(e, 0x3f, sizeof(e)); //WA2
    int n, m;  cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        int u, v, w1, w2;  cin >> u >> v >> w1 >> w2;
        e[u][v] = e[v][u] = w1;
        G[u].push_back({ v,w1,w2 });
        G[v].push_back({ u,w1,w2 });
    }
    //1, floyed跑多源，令最长路最短
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                e[i][j] = min(e[i][j], e[i][k] + e[k][j]);
            }
        }
    }
    int rt = -1, mx = inf;
    for (int i = 1; i <= n; i++) {
        int tmp = 0;
        for (int j = 1; j <= n; j++)
            tmp = max(tmp, e[i][j]);
        if (tmp < mx) {
            mx = tmp;  rt = i;
        }
    }
    //2, Dijkstra跑单源，打印路径
    for (int i = 1; i <= n; i++)dist[i] = inf, pre[i] = -1;
    priority_queue<node>q;
    dist[rt] = 0, dist2[rt] = 0;
    q.push({ rt,dist[rt],dist2[rt] });
    while (q.size()) {
        int u = q.top().u;  q.pop();
        if (vis[u])continue;
        vis[u] = 1;
        for (edge nt : G[u]) {
            int v = nt.to;
            if (dist[v] > dist[u] + nt.w1) {
                dist[v] = dist[u] + nt.w1;
                dist2[v] = dist2[u] + nt.w2;
                pre[v] = u;
                q.push({ v,dist[v], dist2[v] });
            }
            else if (dist[v] == dist[u] + nt.w1 && dist2[nt.to] < dist2[u] + nt.w2) {
                dist2[v] = dist2[u] + nt.w2;
                pre[v] = u;
                q.push({ v,dist[v], dist2[v] });
            }
        }
    }
    //3, T次打印
    cout << rt << "\n";
    int T;  cin >> T;
    while (T--) {
        int x;  cin >> x;
        cout << rt;
        dfs(x);
        cout << "\n";
        cout << dist[x] << " " << dist2[x] << "\n";
    }
    return 0;
}
//7-4疫情防控
//题意：给出n个点，m条边的无向图，接下来d天每天删掉一个点c（累加），然后q次询问每次问删掉c后某两点u, v能否联通。
//思路：考虑暴力O(每天d* 重新建图m* 询问q* 是否联通n)复杂度直接上天。
//这里的难点在于每次删掉一个点后要重新建图需要大量的时间，因为我们可以离线所有的询问反向建图，这样较难的删点就变成了简单的往图上加点，任意两点的连通性也由需要O(n)暴力变成了可以使用并查集logn维护的。
//具体来说：记录下第i天删了谁，有哪些询问。从d天开始往前，每天加一个点，然后并查集直接判断一下是否联通即可。注意加点的时候需要考虑当前点连向的点必须是没有被删的，不然会WA。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int fa[maxn + 10];
void init(int n) { for (int i = 1; i <= n; i++)fa[i] = i; }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) { x = find(x); y = find(y); if (x != y)fa[x] = y; }
vector<int>G[maxn];
vector<pair<int, int> >query[maxn]; //第i天的航班
int dd[maxn], vis[maxn]; //第i天挂了谁，城市i挂了没
int ans[maxn];
int main() {
    int n, m, d;  cin >> n >> m >> d;
    for (int i = 1; i <= m; i++) {
        int u, v;  cin >> u >> v;
        G[u].push_back(v);//存下连通的无向图 因为需要多次删点并查集 
        G[v].push_back(u);
    }
    //离线询问
    for (int i = 1; i <= d; i++) {
        int c, q;  cin >> c >> q;
        vis[c] = 1;
        dd[i] = c;
        while (q--) {
            int u, v;  cin >> u >> v;
            query[i].push_back(make_pair(u, v));
        }
    }
    init(n + 1);
    for (int i = 1; i <= n; i++) {//最后没挂的连起来
        if (vis[i] == 0) {
            for (int j = 0; j < G[i].size(); j++) {
                if (vis[G[i][j]] == 0)merge(i, G[i][j]);
            }

        }
    }
    for (int i = d; i >= 1; i--) {
        for (int j = 0; j < query[i].size(); j++) {
            int x = find(query[i][j].first), y = find(query[i][j].second);
            if (x != y)ans[i]++;
        }
        vis[dd[i]] = 0;  //现在它复活了，加回去
        for (int j = 0; j < G[dd[i]].size(); j++) {
            if (vis[G[dd[i]][j]] == 0)merge(dd[i], G[dd[i]][j]);
        }
    }
    for (int i = 1; i <= d; i++)
        cout << ans[i] << "\n";
    return 0;
}