This might help: International Olympiad in Informatics: Path to Gold

This playlist is mostly based on IARCS syllabus and previous years' papers' trends.

#include <bits/stdc++.h>
#include <list>
long long N;
std::vector <long long> graphs[100010];
bool vis[100010];

arr=list(map(int,input().split()))
n=arr[0]
graph=[[]for i in range(n+1)]
cost=[]
for i in range(1,n+1):

///just get the smallest child for every node than loop over them to get the answer 
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ii pair<int,int>

It is a classical problem.Number of swaps needed is nothing but the number of inversions in the array.

I have solved it using BIT,below is my code.

#include <bits/stdc++.h>

For anyone interested, I found a nice explanation of the crux of the problem.

Sorting a sequence by swapping adjacent elements using minimum swaps

I just submitted a total naive O(n^2) solution and I'm quite surprised to see that it actually worked in 0.08s. CodeChef needs to fix it's test cases. Anyways, I have no clue on how to prove correctness of my algorithm.

Wrong answer on test case 10.

Please, help me. Here's my code:

My logic is that the graph may be a collection of disconnected graphs. So a disconncted graph has a cycle=0 isolated cities, otherwise 1 isolated cities.

#include <bits/stdc++.h>
 
using namespace std;
long long n,m,x,y;
vector <long long> graph[1000000];
bool vis[1000000];
int main()
{
    long long cycle (long long,long long);
    cin>>n>>m;
 
    for(long long i = 0 ; i < m ; i++)
    {
        cin>>x>>y;
        graph[x].push_back(y);
        graph[y].push_back(x);
    }
 
 
    for(long long i = 1 ; i <= n ; i++ )       //This loops helps in navigating through different disconnected graphs
    {
         x=0;                                   // x is used inside cycle()
        if( !vis[ i ] ){   
            vis[1]=1;
            isolated += ( !cycle( i , -1 ) ) ; //if it is a cycle add 0, else add 1
        }
    }
 
    cout<<isolated;
 
    return 0;
}
 
long long cycle(long long cur, long long prev)
{
    long long x=0;
 
    for(unsigned long long i = 0 ; i < graph[cur].size(); i++ )
    { 
        if( !vis[ graph[ cur ][ i ] ] )
        {
            vis[ graph[ cur ][ i ] ] = 1;
            x+=cycle( graph[ cur ][ i ] , cur );
        }
        else if( prev != graph[ cur ][ i ] )
             {
                 x++;   //It has a cycle (so we will add 0 to isolated.
             }
    }
    return x;
}
 

n,m=map(int,input().split())
 
graph=[[]for i in range(n)]
for i in range(m):
  a,b=map(int,input().split())

I was using an unordered hash map for storing the graph as adjacency list and I got some wrong answers. The problem was, I did not observed that in some test cases their might be some cities w...

r,c,d=map(int,input().split())
arr=[]
for i in range(r):
  temp=list(map(int,input().split()))
  arr.append(temp)

class PathNode:
 
    def __init__(self, row, col, st_x, st_y, p_count=0):
        self.x = row
        self.y = col

can you tell me whats wrong in this code

#include<bits/stdc++.h>

#define ll long long