void selection(int n,int* a){
    for (int i = 0;i < n;i++){
        for (int j = i + 1;j < n;j++){
            if (a[i] > a[j]){
                swap(a[i],a[j]);
            }
        }
    }
}

void bubble(int n,int* a){
    for (int i = 0;i < n;i++){
        for (int j = 0;j < n - 1;j++){
            if (a[j] > a[j + 1]){
                swap(a[j],a[j+1]);
            }
        }
    }
}

void quicksort(int l,int r,int* a){
    int i,j,mid;
    i = l;j = r;
    mid = a[(i + j) / 2];
    do{
        while (a[i] < mid) i++;
        while (a[j] > mid) j--;
        if (i <= j){
            swap(a[i],a[j]);
            i++;j--;
        }
    }while (i <= j);
    if (l < j) quicksort(l,j,a);
    if (i < r) quicksort(i,r,a);
}

bool search(int n,int* a,int x){
    for (int i = 0;i < n;i++){
        if (a[i] == x){
            return true;
        }
    }
    return false;
}

bool binary_search(long long* a,int x,int left,int right){
    while(left <= right){    
        int mid = (left + right) / 2;
        if(a[mid] > x) right = mid - 1;
        else if(a[mid] < x) left = mid + 1;
        else return true;
    }
    return false;
}

void dfs(int x,int y,int id){        // id是连通块记号 
    if (是否越界) return;
    if (搜索过或不是指定符号) return;
    标记已搜索; 
    搜索下一步; 
}

#include <iostream>
using namespace std;
typedef struct node;
typedef node *tree;

struct node{
    int data;               // 结点数值
    tree left,right;        // 左子树和右子树 
};
tree bt;

#include <iostream>
using namespace std;
typedef struct node;
typedef node *tree;

struct node{
    int data;                // 结点数值
    tree left,right;        // 左子树和右子树 
};
tree bt;

void preorder(tree bt){
    if (bt){                // 判断不为空二叉树 
        cout << bt.data;
        preorder(bt.left);    // 递归遍历左子树 
        preorder(bt.right); // 递归遍历右子树 
    }
}
void inorder(tree bt){
    if (bt){                // 判断不为空二叉树 
        inorder(bt.left);    // 递归遍历左子树 
        cout << bt.data;
        inorder(bt.right); // 递归遍历右子树 
    }
}
void postorder(tree bt){
    if (bt){                // 判断不为空二叉树 
        postorder(bt.left);    // 递归遍历左子树 
        postorder(bt.right); // 递归遍历右子树 
        cout << bt.data;
    }
}

#include <iostream>
#include <cstring>
using namespace std;

double G[101][101];
int main(){
    int u,v,t,n,m;                        // 结点u到结点v的节点值为t
    cin >> n;
    for (int i = 1;i <= n;i++){
        for (int j = 1;j <= n;j++){
            G[i][j] = 0x7fffffff;        // 初始化为无穷大 
        }
    }
    // 或者使用memset(G,0x7fffffff,sizeof(G))来初始化
    /*
    若是int类型数组，则采用memset(G,0x7f,sizeof(G)))
    0x7fffffff表示无穷大,若是无向图，那么要写成memset(G,0,sizeof(G))
    也可以定义成memset(G,oxaf,sizeof(G)),全都定义成很小的数。 
    */
    cin >> m;
    for (int i = 1;i <= m;i++){
        cin >> u >> v >> t;
        G[u][v] = t;G[v][u] = t;        // 邻接矩阵的值 
    }
    // 输出
    for (int i = 1;i <= n;i++){
        for (int j = 1;j <= n;j++){
            cout << G[i][j] << " ";
        }
        cout << endl;
    } 
    return 0;
}

#include <iostream>
using namespace std;

const int maxn = 10001;
int head[maxn],num,n,m,u,v,t;
struct G{                            // 结构体图G 
    int next,to,dis;
}g[maxn];
void add(int u,int v,int t){        // 添加从结点u到v权值为t的单向边 
    g[++num].next = head[u];
    g[num].to = v;
    g[num].dis = t;
    head[u] = num;
}

int main(){
    num = 0;
    cin >> n >> m;                    // 输入 
    for (int i = 1;i <= m;i++){
        cin >> u >> v >> t;            // 结点u到结点v的权值为t 
        add(u,v,t);
    }
    return 0;
}

bool prime(int n){
    for (int i = 2;i <= sqrt(n);i++){
        if (n % i == 0) return false;
    }
    return true;
}

1 #define _for_1(i,a,b) for(i = (a);i <= (b);i++)
2 #define _for_2(i,a,b) for(i = (a);i >= (b);i--)
3 
4 // 可以这样应用：_for_1(i,1,n)

>g++ 文件名.cpp -o 文件名
>./文件名