#include<bits/stdc++.h>
using namespace std;
#define rep(x, a, m) for (int x = a; x < m; x += 1)
#define FastIO ios_base :: sync_with_stdio (0) ; cin.tie(NULL)
#define ll long long
#define pb push_back
//#define mp make_pair
//vector<pi> g[105];
//(1ll*arr[i]*100 > 1ll*k*s) integre overflow
//cout << (ans==INF?-1:ans) << endl ;
//map<int,vector<int>>mp;
//map<int,pair<int,int>>m1;
//vector<vector<pair<int,int>>>g(10005);
//std::vector<pair<int,int>>edges;
struct E{
int a,b,c;
};
int n,m,w,u,v,k;
int arr[100004];
set<int> s1,s2;
bool campare(ll x,ll y)
{
return (x>=y);
}
/*int knap(int s,int ind)
{
if (ind==0)
{
if (s==0) return dp[ind][s]=1;
return dp[ind][s]=0;
}
if (s>=arr[ind-1])
{
return dp[ind][s]=knap(s-arr[ind-1],ind-1)+knap(s,ind-1);
}
else
{
return dp[ind][s]=knap(s,ind-1);
}
}*/
/*bool dfs(int s,int p)
{
//ok = ok && (color[v] == curr_color);
if (arr[s]!=color) return false;
for(auto j:g[s])
{
if (j==p) continue;
if (!dfs(j,s)) return false;
}
return true;
}
bool can(int s)
{
for(auto k:g[s])
{
color=arr[k];
if (!dfs(k,s)) return false;
}
return true;
}*/
bool cmp(vector<int>var1,vector<int>var2)
{
return (var1[2]<=var2[2]);
}
void solve()
{
cin>>n>>m;
vector<E>edge(m);
rep(i,0,m)
{
cin>>edge[i].a>>edge[i].b>>edge[i].c;
}
//sort(edge.begin(), edge.end());
//sort(edge,edge+m);
/*rep(i,0,m)
{
cout<<edge[i].a<<" "<<edge[i].b<<"\n";
}*/
ll int ans=0;
rep(i,0,m)
{
if (s1.size()<n or s2.size()<n)
{
s1.insert(edge[i].a);
s2.insert(edge[i].b)
ans=max(ans,edge[i].c);
}
else
{
break;
}
}
cout<<ans;
}
/*int mod=1e9+7;
void solve()
{
cin>>n>>m>>k>>w;
rep(i,1,n+1) cin>>arr[i];
rep(i,1,m+1) cin>>ls[i];
//cout<<knap(15000,m)<<"\n";
rep(i,0,151)
{
dp[i][0]=1;
dp1[i][0]=1;
}
rep(i,1,n+1)
{
for(int j=15000;j>0;j--)
{
dp[i][j]=dp[i-1][j];
if (j<arr[i])
{
continue;
}
else
{
dp[i][j]+=dp[i-1][j-arr[i]];
}
dp[i][j]%=mod;
}
}
rep(i,1,m+1)
{
for(int j=15000;j>0;j--)
{
dp1[i][j]=dp1[i-1][j];
if (j<ls[i])
{
continue;
}
else
{
dp1[i][j]+=dp1[i-1][j-ls[i]];
}
dp[i][j]%=mod;
}
}
ll int ans=0;
for (int hasan = 0; hasan <= w; ++hasan) {
int bahosain = w- hasan;
if (abs(hasan - bahosain) <= k)
ans += dp[n][hasan] * dp1[m][bahosain];
ans%=mod;*/
int main()
{
FastIO;
int t=1;
//cin >> t;
for(int i=0; i<t; ++i) {
solve();
cout<<'\n';
}
return 0;
} Write, Run & Share C++ code online using OneCompiler's C++ online compiler for free. It's one of the robust, feature-rich online compilers for C++ language, running on the latest version 17. Getting started with the OneCompiler's C++ compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as C++ and start coding!
OneCompiler's C++ online compiler supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample program which takes name as input and print your name with hello.
#include <iostream>
#include <string>
using namespace std;
int main()
{
string name;
cout << "Enter name:";
getline (cin, name);
cout << "Hello " << name;
return 0;
}
C++ is a widely used middle-level programming language.
When ever you want to perform a set of operations based on a condition If-Else is used.
if(conditional-expression) {
//code
}
else {
//code
}
You can also use if-else for nested Ifs and If-Else-If ladder when multiple conditions are to be performed on a single variable.
Switch is an alternative to If-Else-If ladder.
switch(conditional-expression){
case value1:
// code
break; // optional
case value2:
// code
break; // optional
......
default:
code to be executed when all the above cases are not matched;
}
For loop is used to iterate a set of statements based on a condition.
for(Initialization; Condition; Increment/decrement){
//code
}
While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.
while (condition) {
// code
}
Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.
do {
// code
} while (condition);
Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity. Function gets run only when it is called.
return_type function_name(parameters);
function_name (parameters)
return_type function_name(parameters) {
// code
}