#include <bits/stdc++.h>

using namespace std;
#define MAX 101
#define INFTY 10001

class Edge {
public:
    int source, target, cost;
    Edge(int source = 0,int target = 0,int cost = 0): source(source), target(target), cost(cost) {}
    bool operator < (const Edge &e) const {
        return cost < e.cost;
    }
};
bool visited[MAX], comp[MAX]; //restore cycle groups
int group[MAX];

int solve(std::vector<Edge> &G, int V, int r) {

    std::vector<Edge> mins(V, Edge(-1, -1, INFTY)); //minimum edges

    //target specified min search
    for (unsigned long i = 0; i < G.size(); i++) {
        const Edge &e = G[i];
        mins[e.target] = std::min(mins[e.target], e);
    }
    mins[r] = Edge(-1, r, 0);

    for (int i = 0; i < V; i++) {
        group[i] = 0;
        visited[i] = comp[i] = false;
    }

    int cnt = 0;
    for (int i = 0; i < V; i++) {
        if (!visited[i]) {
            int node = i;
            std::vector<int> path;
            while (node != -1 && !visited[node]) {
                visited[node] = true;
                path.push_back(node);
                node = mins[node].source;
            }

            bool isCycle = false;
            for (unsigned long i = 0; i < path.size(); i++) {
                int current = path[i];
                group[current] = cnt;
                if (current == node)
                    comp[cnt] = isCycle = true;
                if (!isCycle)
                    cnt++;
            }

            if (isCycle)
                cnt++;
        }
    }

    if (cnt == V) {
        int ans = 0;
        for(unsigned long i = 0;i < mins.size(); i++) {
            Edge &e = mins[i];
            ans += e.cost;
        }
        return ans;
    }

    int ans = 0;
    for (unsigned long i = 0; i < mins.size(); i++) {
        Edge &e = mins[i];
        if (comp[group[e.target]])
            ans += e.cost;
    }

    std::vector<Edge> G2;
    for (unsigned long i = 0; i < G.size(); i++) {
        const Edge &e = G[i];
        int source = group[e.source], target = group[e.target], cost = e.cost;
        if (source == target)
            continue;
        else
            G2.push_back(Edge(source, target, cost - (comp[target] ? mins[e.target].cost : 0)));
    }
    return ans + solve(G2, cnt, group[r]);
}

int main() {

    std::vector<Edge> G;
    int V, E, r, source, target, cost;
    std::scanf("%d %d %d", &V, &E, &r);
    for(int i = 0; i< E; i++) {
        std::scanf("%d %d %d", &source, &target, &cost);
        G.push_back(Edge(source, target, cost));
    }
    std::printf("%d\n", solve(G, V, r));
    return 0;
}


