├── BINARY SEARCH
    ├── README.MD
    ├── step1
    │   ├── A.cpp
    │   ├── B.cpp
    │   ├── C.cpp
    │   └── D.cpp
    ├── step2
    │   ├── A.cpp
    │   ├── B.cpp
    │   ├── C.cpp
    │   ├── D.cpp
    │   ├── E.cpp
    │   ├── F.cpp
    │   ├── G.cpp
    │   └── H.cpp
    ├── step3
    │   ├── A.cpp
    │   ├── B.cpp
    │   └── C.cpp
    └── step4
    │   └── A.cpp
├── CSES Additional Problems
    ├── 1087-ShortestSubsequence.cpp
    └── 1146_CountingBits.cpp
├── CSES INTRODUCTORY
    ├── 1068-WeiredAlgorithm.cpp
    ├── 1069-Repetitions.cpp
    ├── 1083-MissingNumber.cpp
    ├── 1094-IncreasingArray.cpp
    └── 1625 Grid_Path.cpp
├── CSES TREES
    ├── 1130-TreeMatching.cpp
    ├── 1131-TreeDiameter.cpp
    ├── 1132-TreeDistance-I(method -1).cpp
    ├── 1133-TreeDistanceII.cpp
    ├── 1135-DistanceQueries.cpp
    ├── 1136-CountingPaths.cpp
    ├── 1137-SubtreeQueries.cpp
    ├── 1674-subordinates.cpp
    ├── 1687 company-queries1.cpp
    └── 1688-Company Queries II.cpp
├── DP
    ├── 1.cpp
    ├── 2.cpp
    ├── 3.cpp
    ├── 4.cpp
    ├── 5.cpp
    ├── 6.cpp
    ├── DP-bitmasking
    │   ├── README.MD
    │   ├── leetcodemincost2connectpoints.cpp
    │   ├── sol1.cpp
    │   └── solkickstart.cpp
    ├── README.MD
    ├── cses dp
    │   ├── 1093-TwoSetsII.cp
    │   ├── 1097-RemovalGames.cpp
    │   ├── 1140-Projects.cpp
    │   ├── 1145-IncreasingSubsequence.cpp
    │   ├── 1158-BookShop.cpp
    │   ├── 1633-DiceCombinations.cpp
    │   ├── 1634-MinimizingCoins.cpp
    │   ├── 1635-CoinCombinations.cpp
    │   ├── 1636-CoinCombinationII.cpp
    │   ├── 1637-RemoveDigits.cpp
    │   ├── 1638-GridPaths.cpp
    │   ├── 1639-EditDistance.cpp
    │   ├── 1653-ElevatorRide.cpp
    │   ├── 1744-ReactangularCutting.cpp
    │   ├── 1745-MoneySum.cpp
    │   ├── 1746-Arraydescription.cpp
    │   ├── 2181-CountingTilings.cpp
    │   ├── 2220-CountingNumbers.cpp
    │   └── 2413-CountingTowers.cpp
    └── digit-dp
    │   ├── README.MD
    │   ├── kickstartroundA22problemD.cpp
    │   ├── soln1usingP&C.cpp
    │   └── soln1usingdigitdp.cpp
├── Google Online Coding Challenge 2022
    └── problem1.cpp
├── Interactive problems
    ├── 1.cpp
    ├── 10.cpp
    ├── 11.cpp
    ├── 12.cpp
    ├── 2.cpp
    ├── 3.cpp
    ├── 4.cpp
    ├── 5.cpp
    ├── 7.cpp
    ├── 8.cpp
    ├── 9.cpp
    └── README.MD
├── RANGE Queries
    ├── README.MD
    └── cses
    │   ├── 1143-HotelQueries.cpp
    │   ├── 1190-SubarraySumQueries.cpp
    │   ├── 1646-staticRangeSumQueries.cpp
    │   ├── 1647-StaticRangeMinQueries.cpp
    │   ├── 1648-DynamicRangeSumQueries.cpp
    │   ├── 1649-DynamicRangeMinQueries.cpp
    │   ├── 1650-RangeXorQueries.cpp
    │   ├── 1651-RangeUpdateQueries.cpp
    │   ├── 1652-ForestQueries.cpp
    │   ├── 1749-ListRemovals.cpp
    │   ├── 2166-PrefixSumQueries.cpp
    │   └── 2206-PizzeriaQueries.cpp
├── README.md
├── String Algorithms
    ├── CSES
    │   ├── 1731-WordCombinations.cpp
    │   ├── 1732-FindingBorders.cpp
    │   ├── 1733-FindingPeriods.cpp
    │   └── 1753-StringMatching.cpp
    └── README.MD
├── Templates
    ├── SieveOfEratosthenes
    ├── binar_lifting.cpp
    ├── ext_gcd.cpp
    ├── nCr-2.cpp
    ├── nCr-main
    ├── nCr.cpp
    └── segtree.cpp
├── cses graph
    ├── 1192 CountingRooms.cpp
    ├── 1193 Labyrinth.cpp
    ├── 1194 Monsters.cpp
    ├── 1195 Flight discount.cpp
    ├── 1196 FlightRoutes.cpp
    ├── 1197 CycleFinding.cpp
    ├── 1202 Investigation.cpp
    ├── 1666 Building Roads.cpp
    ├── 1667 Message Route.cpp
    ├── 1669 Round Trip.cpp
    ├── 1671 Shortest Routes I.cpp
    ├── 1672 Shortest Routes II.cpp
    ├── 1673 High_score.cpp
    ├── 1675-RoadConstruction.cpp
    ├── 1676-Road Construction.cpp
    ├── 1679 CouseShedule.cpp
    ├── 1680 longestFlightRoute(dijkastra).cpp
    ├── 1680 longestFlightRoute(optimised).cpp
    ├── 1681 GameRoutes.cpp
    ├── 1682-FlightRouteCheck.cpp
    ├── 1683-planets And Kingdoms.cpp
    ├── 1684-Giant Pizza.cpp
    ├── 1686 Building Teams.cpp
    ├── 1686 Coin Collector.cpp
    ├── 1750 PlanetQueries1.cpp
    ├── 1751-PlanetsCycles.cpp
    └── README.MD
└── playing with bits
    └── readme.md


/BINARY SEARCH/README.MD:
--------------------------------------------------------------------------------
1 | CodeforcesEDU course:-
2 | https://codeforces.com/edu/course/2/lesson/6
3 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step1/A.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | bool binarysearch(ll arr[],ll l,ll r,ll val)
15 | {
16 |    
17 |     if(l>r)
18 |     {
19 |         return false;
20 |     }
21 |     ll mid=(l+r)/2;
22 |     if(arr[mid]==val)
23 |     {
24 |         return true;
25 |     }else if(arr[mid]>val)
26 |     {
27 |         return binarysearch(arr,l,mid-1,val);
28 |     }else
29 |     {
30 |         return binarysearch(arr,mid+1,r,val);
31 |     }
32 |     
33 | }
34 |  
35 | int main()
36 | {
37 |     ll n,k;
38 |     cin>>n>>k;
39 |     ll arr[n];
40 |     for(ll i=0;i<n;i++)
41 |     {
42 |         cin>>arr[i];
43 |     }
44 |     while(k--)
45 |     {
46 |         ll val;
47 |         cin>>val;
48 |         if(binarysearch(arr,0,n,val))
49 |         {
50 |             cout<<"YES"<<endl;
51 |         }else
52 |         {
53 |             cout<<"NO"<<endl;
54 |         }
55 |     }
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step1/B.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | ll binarysearch(ll arr[],ll l,ll r,ll val)
15 | {
16 |    
17 |     
18 |     ll mid=(l+r)/2;
19 |     
20 |     if(r-l==1  && arr[mid]<=val)
21 |     {
22 |         return r;
23 |     }
24 |     if(r-l==1 && arr[mid]>val)
25 |     {
26 |         return 0;
27 |     }
28 |     if(arr[mid]>val)
29 |     {
30 |         return binarysearch(arr,l,mid,val);
31 |     }else if(arr[mid]<=val)
32 |     {
33 |         return binarysearch(arr,mid,r,val);
34 |     }
35 |     return 0;
36 |     
37 | }
38 |  
39 | int main()
40 | {
41 |     ll n,k;
42 |     cin>>n>>k;
43 |     ll arr[n];
44 |     for(ll i=0;i<n;i++)
45 |     {
46 |         cin>>arr[i];
47 |     }
48 |     while(k--)
49 |     {
50 |         ll val;
51 |         cin>>val;
52 |         cout<<binarysearch(arr,-1,n,val)<<endl;
53 |         
54 |     }
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step1/C.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | ll binarysearch(ll arr[],ll l,ll r,ll val)
15 | {
16 |     if(r-l==1)
17 |     {
18 |         return r+1;
19 |     }
20 |     ll mid=(l+r)/2;
21 |     if(arr[mid]>=val)
22 |     {
23 |         return binarysearch(arr,l,mid,val);
24 |     }else
25 |     {
26 |         return binarysearch(arr,mid,r,val);
27 |     }
28 |     // return -1;
29 |     
30 | }
31 |  
32 | int main()
33 | {
34 |     ll n,k;
35 |     cin>>n>>k;
36 |     ll arr[n];
37 |     for(ll i=0;i<n;i++)
38 |     {
39 |         cin>>arr[i];
40 |     }
41 |     while(k--)
42 |     {
43 |         ll val;
44 |         cin>>val;
45 |         cout<<binarysearch(arr,-1,n,val)<<endl;
46 |         
47 |     }
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step1/D.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | ll binarysearch1(ll arr[],ll l,ll r,ll val)
15 | {
16 |     if(r-l==1)
17 |     {
18 |         return r+1;
19 |     }
20 |     ll mid=(l+r)/2;
21 |     if(arr[mid]>=val)
22 |     {
23 |         return binarysearch1(arr,l,mid,val);
24 |     }else
25 |     {
26 |         return binarysearch1(arr,mid,r,val);
27 |     }
28 |     // return -1;
29 | }
30 | ll binarysearch2(ll arr[],ll l,ll r,ll val)
31 | {
32 |     if(r-l==1)
33 |     {
34 |         return l+1;
35 |     }
36 |     ll mid=(l+r)/2;
37 |     if(arr[mid]>val)
38 |     {
39 |         return binarysearch2(arr,l,mid,val);
40 |     }else
41 |     {
42 |         return binarysearch2(arr,mid,r,val);
43 |     }
44 |     // return -1;
45 | }
46 |  
47 |  
48 |  
49 |  
50 | int main()
51 | {
52 |     ll n,k;
53 |     cin>>n;
54 |     ll arr[n];
55 |     for(ll i=0;i<n;i++)
56 |     {
57 |         cin>>arr[i];
58 |     }
59 |     sort(arr,arr+n);
60 |     cin>>k;
61 |     while(k--)
62 |     {
63 |         ll val1,val2;
64 |         cin>>val1>>val2;
65 |         cout<<binarysearch2(arr,-1,n,val2)-binarysearch1(arr,-1,n,val1)+1<<" ";    
66 |     }
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/A.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | ll w,h,n;
14 |  
15 | bool good(ll x)
16 | {
17 |     return (x/w)*(x/h)>=n;
18 | }
19 |  
20 |  
21 | int main()
22 | {
23 |     // ll w,h,n;
24 |     cin>>w>>h>>n;
25 |  
26 |     ll l=0;
27 |     ll r=1;
28 |     while(!good(r))
29 |     {
30 |         r*=2;
31 |     }    
32 |  
33 |     while(r>l+1)
34 |     {
35 |         ll mid=(l+r)/2;
36 |         if(good(mid))
37 |         {
38 |             r=mid;
39 |         }else{
40 |             l=mid;
41 |         }
42 |     }
43 |     cout<<r<<endl;
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/B.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | ll n,k;
14 |  
15 |  
16 | bool notgood(double x,ll arr[])
17 | {
18 |     ll total=0;
19 |     for(ll i=0;i<n;i++)
20 |     {
21 |         total+=((ll)(arr[i]/x));
22 |     }
23 |     if(total<k)
24 |     {
25 |         return true;
26 |     }
27 |     return false;
28 |  
29 | }
30 |  
31 |  
32 | int main()
33 | {
34 |     // ll w,h,n;
35 |     cin>>n>>k;
36 |     ll arr[n];
37 |     for(ll i=0;i<n;i++)
38 |     {
39 |         cin>>arr[i];
40 |     }
41 |  
42 |     double l=0;
43 |     double r=1;
44 |     while(!notgood(r,arr))
45 |     {
46 |         r*=2;
47 |     }    
48 |      cout << setprecision(20) ;
49 |     while(r>l+0.0000001)
50 |     {
51 |         double mid=(l+r)/2.0;
52 |         if(notgood(mid,arr))
53 |         {
54 |             r=mid;
55 |         }else{
56 |             l=mid;
57 |         }
58 |     }
59 |     cout<<l<<endl;
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/C.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | ll n,x,y;
14 |  
15 |  
16 | bool good(ll z)
17 | {
18 |     return (z/x)+(z/y)>=n-1;
19 |  
20 | }
21 |  
22 |  
23 | int main()
24 | {
25 |     // ll w,h,n;
26 |     cin>>n>>x>>y;
27 |     // n=n+1;
28 |     if(n==1)
29 |     {
30 |         cout<<min(x,y)<<endl;
31 |         return 0;
32 |     }
33 |     ll l=0;
34 |     ll r=1;
35 |     while(!good(r))
36 |     {
37 |         r*=2;
38 |     }    
39 |     
40 |     while(r>l+1)
41 |     {
42 |         ll mid=(l+r)/2;
43 |         if(good(mid))
44 |         {
45 |             r=mid;
46 |         }else{
47 |             l=mid;
48 |         }
49 |     }
50 |     cout<<r+min(x,y)<<endl;
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/D.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // sab moh maya hai...
  6 |  
  7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
  8 |  
  9 | #include<bits/stdc++.h>
 10 | using namespace std;
 11 |  
 12 | #define ll long long
 13 | ll m,n;
 14 | ll ans[100005]={0};
 15 | bool good(ll time, ll t[], ll z[] , ll y[])
 16 | {
 17 |     ll total=0;
 18 |     for(ll i=0;i<n;i++)
 19 |     {
 20 |         total+=((time/(z[i]*t[i] + y[i]))*z[i]);
 21 |         ll rem= time%(z[i]*t[i] + y[i]);
 22 |         if(rem/t[i]>z[i])
 23 |         {
 24 |             total+=z[i];
 25 |         }else{
 26 |             total+=(rem/t[i]);
 27 |         }
 28 |  
 29 |     }
 30 |     // cout<<total<<" ";
 31 |     // cout<<time<<endl;
 32 |     return total>=m;
 33 |  
 34 | }
 35 |  
 36 | void result(ll time, ll t[], ll z[] , ll y[],ll ans[])
 37 | {
 38 |     ll total=0;
 39 |  
 40 |     for(ll i=0;i<n;i++)
 41 |     {
 42 |         ans[i]+=(time/(z[i]*t[i] + y[i]))*z[i];
 43 |         ll rem= time%(z[i]*t[i] + y[i]);
 44 |         if(rem/t[i]>z[i])
 45 |         {
 46 |             ans[i]+=z[i];
 47 |         }else{
 48 |             ans[i]+=(rem/t[i]);
 49 |         }
 50 |         total+=ans[i];
 51 |         if(total>=m)
 52 |         {
 53 |             ans[i]-=(total-m);
 54 |             return;
 55 |         }
 56 |  
 57 |     }
 58 |     
 59 |  
 60 | }
 61 |  
 62 | int main()
 63 | {
 64 |     
 65 |     cin>>m>>n;
 66 |     ll t[n],z[n],y[n];
 67 |     ll mn=INT_MAX;
 68 |     ll b=0;
 69 |     for(ll i=0;i<n;i++)
 70 |     {
 71 |         cin>>t[i]>>z[i]>>y[i];
 72 |         if(mn>t[i])
 73 |         {
 74 |             mn=t[i];
 75 |             b=i;
 76 |         }
 77 |     }
 78 |     
 79 |     // memset(ans,0,sizeof(ans));
 80 |     
 81 |     ll l=-1;
 82 |     ll r=1e9;
 83 |     
 84 |     // cout<<"value of r: ";
 85 |     // cout<<r<<endl;
 86 |  
 87 |     while(r>l+1)
 88 |     {
 89 |         ll mid=(l+r)/2;
 90 |         if(good(mid,t,z,y))
 91 |         {
 92 |             r=mid;
 93 |         }else
 94 |         {
 95 |             l=mid;
 96 |         }
 97 |     }
 98 |     result(r,t,z,y,ans);
 99 |     cout<<r<<endl;
100 |     for(ll i=0;i<n;i++)
101 |     {
102 |         cout<<ans[i]<<" ";
103 |     }
104 |  
105 |     
106 | }
107 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/E.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai...
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | double c;
14 | bool good(double root)
15 | {
16 |     return root*root + sqrt(root)>=c;
17 | }
18 |  
19 |  
20 |  
21 | int main()
22 | {
23 |     
24 |     
25 |     cin>>c;
26 |  
27 |     double l=0,r=1.0;
28 |     while(!good(r))
29 |     {
30 |         r*=2;
31 |     }
32 |     cout<< setprecision(20);
33 |     while(r>l+0.0000001)
34 |     {
35 |         double mid=(l+r)/2.0;
36 |         if(good(mid))
37 |         {
38 |             r=mid;
39 |         }else{
40 |             l=mid;
41 |         }
42 |     }
43 |     cout<<r<<endl;
44 |     
45 |  
46 |  
47 |     
48 | }
49 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/F.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai...
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | bool good(ll arr[],ll mid,string t,string p)
15 | {
16 |     ll check=p.length();
17 |     ll len=t.length();
18 |     for(ll i=0;i<mid;i++)
19 |     {
20 |         t[arr[i]-1]='0';
21 |     }
22 |     // cout<<len<<endl;
23 |     ll tr=0,pr=0;
24 |     while(tr<len && pr<check)
25 |     {
26 |         if(t[tr]==p[pr])
27 |         {
28 |             pr++;
29 |         }
30 |         tr++;
31 |     }
32 |     return (pr>=check);
33 |  
34 | }
35 |  
36 |  
37 |  
38 | int main()
39 | {
40 |     
41 |     string t,p;
42 |     cin>>t>>p;
43 |     ll len=t.length();
44 |     ll arr[len];
45 |     for(ll i=0;i<len;i++)
46 |     {
47 |         cin>>arr[i];
48 |     }
49 |     ll l=-1,r=len;
50 |     // cout<<r<<endl;
51 |     while(r>l+1)
52 |     {
53 |         ll mid=(l+r)/2;
54 |         if(good(arr,mid,t,p))
55 |         {
56 |             l=mid;
57 |  
58 |         }else
59 |         {
60 |             r=mid;
61 |             
62 |         }
63 |     }
64 |     // if(good(arr,l,t,p))
65 |     cout<<l<<endl;
66 |  
67 |     return 0;
68 | }
69 |  
70 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/G.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 6 |  
 7 | // sab moh maya hai...
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | int main()
15 | {
16 |     ll k,n;
17 |     cin>>k>>n;
18 |     ll arr[n];
19 |     ll sm=0;
20 |     for(ll i=0;i<n;i++)
21 |     {
22 |         cin>>arr[i];
23 |         sm+=arr[i];
24 |     }
25 |     sort(arr,arr+n);
26 |  
27 |         ll r=(sm+k-1)/k;
28 |         r++;
29 |         ll l=1;
30 |         while(l+1<r){
31 |  
32 |  
33 |             ll mid=(l+r)/2;
34 |             //check if this number of councils is possible
35 |             ll req=mid*k;
36 |             for(ll i=0;i<n;i++){
37 |  
38 |                 req-=min(mid,arr[i]);
39 |                 if(req<=0)break;
40 |             }
41 |             if(req<=0){
42 |  
43 |                 l=mid;
44 |             }
45 |             else r=mid;
46 |         }
47 |         cout<<l<<endl;
48 |  
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step2/H.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 6 |  
 7 | // sab moh maya hai...
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | int main()
15 | {
16 |     ll k,n;
17 |     cin>>k>>n;
18 |     ll arr[n];
19 |     ll sm=0;
20 |     for(ll i=0;i<n;i++)
21 |     {
22 |         cin>>arr[i];
23 |         sm+=arr[i];
24 |     }
25 |     sort(arr,arr+n);
26 |  
27 |         ll r=1e12;
28 |         ll l=1;
29 |         ll ans=0;
30 |         while(l<=r){
31 |  
32 |  
33 |             ll mid=(l+r)/2;
34 |             
35 |             ll req=mid*k;
36 |             for(ll i=0;i<n;i++){
37 |  
38 |                 req-=min(mid,arr[i]);
39 |                 if(req<=0)break;
40 |             }
41 |             if(req<=0){
42 |                 ans=mid;
43 |                 l=mid+1;
44 |             }
45 |             else r=mid-1;
46 |         }
47 |         cout<<ans<<endl;
48 |  
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step3/A.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai...
 6 |  
 7 | // give me some sunshine , give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | double findmx(ll n,vector<pair<double,double>> vec,double pos)
15 | {
16 |     double mn= -DBL_MAX;
17 |     double ans;
18 |     for(ll i=0;i<n;i++)
19 |     {
20 |         double t= abs(vec[i].first-pos)/vec[i].second;
21 |         if(t>mn)
22 |         {
23 |             mn=t;
24 |             ans=vec[i].first;
25 |         }
26 |     }
27 |     // cout<<mn<<" ";
28 |  
29 |     return ans;
30 |  
31 | }
32 |  
33 | void findmx1(ll n,vector<pair<double,double>> vec,double pos)
34 | {
35 |     double mn= -DBL_MAX;
36 |     double ans;
37 |     for(ll i=0;i<n;i++)
38 |     {
39 |         double t= abs(vec[i].first-pos)/vec[i].second;
40 |         if(t>mn)
41 |         {
42 |             mn=t;
43 |             ans=vec[i].first;
44 |         }
45 |     }
46 |     cout<<mn<<" ";
47 |  
48 |  
49 | }
50 |  
51 | int main()
52 | {
53 |  
54 |     ll n;
55 |     cin>>n;
56 |     // double x[n],v[n];
57 |     double l=-1000000000.0,r=1000000000.0;
58 |  
59 |     vector<pair<double,double>> vec;
60 |     for(ll i=0;i<n;i++)
61 |     {
62 |         ll x,v;
63 |         cin>>x>>v;
64 |         vec.push_back(make_pair(x,v));
65 |     }
66 |  
67 |     cout<< setprecision(7);
68 |     sort(vec.begin(),vec.end());
69 |     while(r>l+0.0000001)
70 |     {
71 |         double mid=(l+r)/2.0;
72 |         if(findmx(n,vec,mid)<=mid)
73 |         {
74 |             r=mid;
75 |         }else
76 |         {
77 |             l=mid;
78 |         }
79 |         
80 |  
81 |     }
82 |     
83 |     findmx1(n,vec,r);
84 |  
85 |  
86 |  
87 |     return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step3/B.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai...
 6 |  
 7 | // give me some sunshine , give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | bool sumseg(ll arr[],ll n,ll sum,ll k)
15 | {
16 |     ll val=0;
17 |     ll cnt=0;
18 |     ll ans=0;
19 |     for(ll i=0;i<n;i++)
20 |     {
21 |         val+=arr[i];
22 |         if(val>sum)
23 |         {
24 |             val=arr[i];
25 |             cnt++;
26 |         }
27 |         ans=max(ans,val);
28 |     }
29 |     // cout<<ans<<endl;
30 |     return (cnt<k);
31 |  
32 | }
33 |  
34 | void sumseg1(ll arr[],ll n,ll sum,ll k)
35 | {
36 |     ll val=0;
37 |     ll cnt=0;
38 |     ll ans=0;
39 |     for(ll i=0;i<n;i++)
40 |     {
41 |         val+=arr[i];
42 |         if(val>sum)
43 |         {
44 |             val=arr[i];
45 |             cnt++;
46 |         }
47 |         ans=max(ans,val);
48 |     }
49 |     cout<<ans<<endl;
50 |     
51 |  
52 | }
53 |  
54 |  
55 | int main()
56 | {
57 |  
58 |     ll n,k;
59 |     cin>>n>>k;
60 |     ll arr[n];
61 |     ll mn=INT_MIN;
62 |     for(ll i=0;i<n;i++)
63 |     {
64 |         cin>>arr[i];
65 |         mn=max(arr[i],mn);
66 |     }
67 |     // cout<<mn<<endl;
68 |     ll l=mn,r=1;
69 |     while(!sumseg(arr,n,r,k))
70 |     {
71 |         r*=2;
72 |     }
73 |  
74 |     // cout<<r<<endl;
75 |  
76 |     while(r>l+1)
77 |     {
78 |         ll mid=(l+r)/2;
79 |         if(sumseg(arr,n,mid,k))
80 |         {
81 |             r=mid;
82 |         }else
83 |         {
84 |             l=mid;
85 |         }
86 |     }
87 |     // cout<<r<<endl;
88 |     sumseg1(arr,n,r,k);
89 |  
90 |  
91 |     return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step3/C.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai..
 6 |  
 7 | // give me some sunshine give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | bool good(ll arr[],ll n,ll val,ll k)
15 | {
16 |     ll ch=arr[0];
17 |     ll cnt=1;
18 |     for(ll i=1;i<n;i++)
19 |     {
20 |         if(arr[i]-ch >=val)
21 |         {
22 |             cnt++;
23 |             ch=arr[i];
24 |         }
25 |     }
26 |     return (cnt>=k);
27 | }
28 |  
29 | void ans(ll arr[],ll n,ll val)
30 | {
31 |     ll ch=arr[0];
32 |     ll res=INT_MAX;
33 |     for(ll i=1;i<n;i++)
34 |     {
35 |         if((arr[i]-ch) >= val)
36 |         {
37 |             
38 |             res=min(res,arr[i]-ch);
39 |             ch=arr[i];
40 |         }
41 |     }
42 |     cout<<res<<endl;
43 | }
44 |  
45 |  
46 | int main()
47 | {
48 |     ll n,k;
49 |     cin>>n>>k;
50 |  
51 |     ll arr[n];
52 |     for(ll i=0;i<n;i++)
53 |     {
54 |         cin>>arr[i];
55 |     }
56 |     ll l=0,r=1e9;
57 |  
58 |     while(r>l+1)
59 |     {
60 |         ll mid=(l+r)/2;
61 |         if(good(arr,n,mid,k))
62 |         {
63 |             l=mid;
64 |         }else
65 |         {
66 |             r=mid;
67 |  
68 |         }
69 |  
70 |  
71 |     }
72 |     ans(arr,n,l);
73 |     return 0;
74 |  
75 | }
76 | 


--------------------------------------------------------------------------------
/BINARY SEARCH/step4/A.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // sab moh maya hai....
 6 |  
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 | ll n,d;
15 | ll arr[100005];
16 |  
17 |  
18 | bool ischeck(double x){
19 |     double brr[n];
20 |     for(ll i=0;i<n;i++){
21 |         brr[i]=(double)arr[i]-x;
22 |         if(i>=1){
23 |             brr[i]+=brr[i-1];
24 |         }
25 |     }
26 |     double mn=0.0;
27 |     for(ll i=d-1;i<n;i++){
28 |         if(brr[i]>=mn){
29 |             return true;
30 |         }
31 |         mn=min(mn,brr[i-d+1]);
32 |     }
33 |     return false;
34 |     
35 |  
36 | }
37 |  
38 | pair<ll,ll> find(double x){
39 |     double brr[n];
40 |     for(ll i=0;i<n;i++){
41 |         brr[i]=(double)arr[i]-x;
42 |         if(i>=1){
43 |             brr[i]+=brr[i-1];
44 |         }
45 |     }
46 |     double mn=0.0;
47 |     ll in=-1;
48 |     for(ll i=d-1;i<n;i++){
49 |         if(brr[i]>=mn){
50 |             // return true;
51 |             return {in,i};
52 |             
53 |         }
54 |         if(brr[i-d+1]<mn){
55 |             in=i-d+1;
56 |             mn=brr[i-d+1];
57 |         }
58 |         // mn=min(mn,brr[i-d+1]);
59 |     }
60 |     return {-1,-1};
61 |     
62 |  
63 | }
64 |  
65 | int main(){
66 |     
67 |     cin>>n>>d;
68 |     
69 |     ll l1=101,r1=0;
70 |     for(ll i=0;i<n;i++){
71 |         cin>>arr[i];
72 |         l1=min(l1,arr[i]);
73 |         r1=max(r1,arr[i]);
74 |     }
75 |     double l=(double)l1;
76 |     double r=(double)r1;
77 |  
78 |     while(r>l+0.00000001){
79 |         double mid=(l+r)/2.0;
80 |         // cout<<mid<<endl;
81 |         if(ischeck(mid)){
82 |             l=mid;
83 |         }else{
84 |             r=mid;
85 |         }
86 |     }
87 |  
88 |     pair<ll,ll> pr=find(l);
89 |     cout<<pr.first+2<<" "<<pr.second+1<<endl;
90 |     
91 |     return 0;
92 | }
93 | 


--------------------------------------------------------------------------------
/CSES Additional Problems/1087-ShortestSubsequence.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | #define ull unsigned long long int
14 | #define mod 1000000007
15 | 
16 | int main(){
17 |     ios_base::sync_with_stdio(false);
18 |     cin.tie(NULL);
19 | 
20 |     string s;
21 |     cin>>s;
22 |     ll n=s.length();
23 | 
24 |     string ans="";
25 | 
26 |     map<char,ll> mp1;
27 |     mp1['A']=1;
28 |     mp1['C']=1;
29 |     mp1['G']=1;
30 |     mp1['T']=1;
31 | 
32 |     map<char,ll> mp2;
33 |     mp2=mp1;
34 |     ll cnt=0;
35 |     for(ll i=0;i<n;i++){
36 |         
37 |         if(mp2[s[i]]==1){
38 |             mp2[s[i]]=0;
39 |             cnt++;
40 |         }
41 |         if(cnt==4){
42 | 
43 |             // cout<<i<<endl;
44 |             cnt=0;
45 |             mp2=mp1;
46 |             ans+=s[i];
47 |         }
48 |     }
49 | 
50 |     // cout<<ans<<endl;
51 |     bool check=false;
52 | 
53 |     for(auto i:mp2){
54 |         // cout<<i.first<<" "<<i.second<<endl;
55 |         if(i.second==1){
56 |             ans+=(i.first);
57 |             check=true;
58 |             break;
59 |         }
60 |     }
61 | 
62 |     if(!check){
63 |         ans+="A";
64 |     }
65 | 
66 | 
67 |     cout<<ans<<endl;
68 | 
69 | 
70 | 
71 | 
72 | 
73 | 
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/CSES Additional Problems/1146_CountingBits.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | #define ull unsigned long long int
14 | 
15 | int main(){
16 |     ios_base::sync_with_stdio(false);
17 |     cin.tie(NULL);
18 | 
19 |     ll n;
20 |     cin>>n;
21 | 
22 | 
23 |     vector<ll> vec;
24 | 
25 |     ll temp=n;
26 |     while(temp!=0){
27 |         vec.push_back(temp%2);
28 |         temp/=2;
29 |     }
30 | 
31 |     reverse(vec.begin(),vec.end());
32 |     ll cnt=vec.size() -1;
33 | 
34 |     ull ans=0;
35 | 
36 |     ll val=0;
37 | 
38 |     // ll ans1=0;
39 |     // for(ll i=1;i<=n;i++){
40 |     //     temp=i;
41 |     //     while(temp!=0){
42 |     //         ans1+=temp%2;
43 |     //         temp/=2;
44 |     //     }
45 |     // }
46 | 
47 |     // cout<<ans1<<e
48 |     ll vl=pow(2,cnt);
49 |     for(auto i:vec){
50 |         // cout<<i<<" ";
51 |         
52 |         if(i==1){
53 |             if(cnt>=0){
54 |                 ans+=(ull)((cnt)*(ull)(vl/2));
55 |                 ans+=(ull)((ull)(vl)*(val));
56 |             }
57 |             val++;
58 |         }
59 |         vl/=2;
60 | 
61 | 
62 |         cnt--;
63 |     }
64 |     // cout<<endl;
65 |     ans+=val;
66 | 
67 | 
68 |     cout<<ans<<endl;
69 | 
70 | 
71 | 
72 | 
73 | 
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/CSES INTRODUCTORY/1068-WeiredAlgorithm.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 |  
15 |  
16 | int main()
17 | {
18 |     ios_base::sync_with_stdio(false);
19 |     cin.tie(NULL);
20 |     ll n;
21 |     cin>>n;
22 |     while(n!=1){
23 |         cout<<n<<" ";
24 |         if(n%2){
25 |             n*=3;
26 |             n++;
27 |         }else{
28 |             n/=2;
29 |         }
30 |     }
31 |     cout<<"1"<<endl;
32 |     
33 |  
34 |     return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/CSES INTRODUCTORY/1069-Repetitions.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | int main()
15 | {
16 |     ios_base::sync_with_stdio(false);
17 |     cin.tie(NULL);
18 | 
19 |     string s;
20 |     cin>>s;
21 |     s+='*';
22 |     ll c=1;
23 |     ll mx=0;
24 |     for(int i=1;i<s.length();i++){
25 |         if(s[i]==s[i-1]){
26 |             c++;
27 |         }else{
28 |             mx=max(mx,c);
29 |             c=1;
30 |         }
31 |     }
32 |     cout<<mx<<endl;
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/CSES INTRODUCTORY/1083-MissingNumber.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | int main()
15 | {
16 |     ios_base::sync_with_stdio(false);
17 |     cin.tie(NULL);
18 | 
19 |     
20 |         ll n;
21 |         cin >> n;
22 |         ll val=0;
23 |         for(ll i=0;i<n-1;i++){
24 |             ll x;
25 |             cin>>x;
26 |             val=val^x;
27 |             val=val^(i+1);
28 |         }
29 |         val^=n;
30 |         cout<<val<<endl;
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/CSES INTRODUCTORY/1094-IncreasingArray.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | int main()
15 | {
16 |     ios_base::sync_with_stdio(false);
17 |     cin.tie(NULL);
18 |     ll n;
19 |     cin>>n;
20 |     ll arr[n];
21 |     ll ans=0;
22 |     for(ll i=0;i<n;i++){
23 |         cin>>arr[i];
24 |         if(i>0){
25 |             if(arr[i]<arr[i-1]){
26 |                 ans+=(arr[i-1]-arr[i]);
27 |                 arr[i]=arr[i-1];
28 |             }
29 |         }
30 | 
31 |     }
32 |     cout<<ans<<endl;
33 | 
34 |     return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/CSES TREES/1130-TreeMatching.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | 
 5 | #define ll unsigned long long
 6 | #define mod 1000000007
 7 | 
 8 | vector<ll> graph[200005];
 9 | vector<bool> visited(200005, false);
10 | ll dp[200005][2];
11 | vector<ll> vec;
12 | ll ans=0;
13 | 
14 | void dfs(ll v,ll par)
15 | {
16 |     visited[v] = true;
17 |     ll x=0;
18 | 
19 |     bool flag=false;
20 |     for (auto u : graph[v])
21 |     {
22 |         if (!visited[u])
23 |         {
24 |             dfs(u,v);
25 |             // dp[v]=dp[u];
26 |             x+=max(dp[u][0],dp[u][1]); 
27 |             if(dp[u][0]+1>dp[u][1] && !flag){
28 |                 flag=true;
29 |                 x++;
30 |             } 
31 |         }
32 |     }
33 |     if(flag){
34 |         dp[v][1]=x;
35 |         dp[v][0]=x-1;
36 |     }else{
37 |         dp[v][0]=x;
38 |     }
39 |     ans=max(ans,dp[v][0]);
40 |     ans=max(ans,dp[v][1]);
41 | 
42 | }
43 | 
44 | int main()
45 | {
46 |     ios_base::sync_with_stdio(false);
47 |     cin.tie(NULL);
48 | 
49 |     ll n;
50 |     cin >> n;
51 |     for (ll i = 0; i < n - 1; i++)
52 |     {
53 |         ll u, v;
54 |         cin >> u >> v;
55 |         graph[u].push_back(v);
56 |         // graph[u].push_back(v);
57 |         graph[v].push_back(u);
58 |         
59 |     }
60 |     
61 |     dfs(1,0);
62 | 
63 |     
64 |     cout << ans << endl;
65 | 
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/CSES TREES/1131-TreeDiameter.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | 
 5 | #define ll unsigned long long
 6 | #define mod 1000000007
 7 | 
 8 | vector<ll> graph[200005];
 9 | vector<bool> visited(200005, false);
10 | ll ans=0;
11 | ll mxx=0;
12 | ll prv=0;
13 | ll v1,v2;
14 | 
15 | vector<pair<ll,ll>> vec;
16 | void dfs(ll v)
17 | {
18 |     visited[v] = true;
19 |     ll x=0;
20 | 
21 |     bool flag=false;
22 |     for (auto u : graph[v])
23 |     {
24 |         if (!visited[u])
25 |         {
26 |             mxx++;
27 | 
28 |             vec.push_back({mxx,u});
29 | 
30 |             dfs(u);
31 |             mxx--;
32 |         }
33 |     }
34 | }
35 | 
36 | bool flag=false;
37 | 
38 | void dfss(ll v){
39 |     if(flag){
40 |         return ;
41 |     }
42 |     visited[v]=true;
43 |     for(auto u:graph[v]){
44 |         if(!visited[u]){
45 |             mxx++;
46 |             ans=max(ans,mxx);
47 |             dfss(u);
48 |             mxx--;
49 |         }
50 |     }
51 | }
52 | 
53 | 
54 | 
55 | int main()
56 | {
57 |     ios_base::sync_with_stdio(false);
58 |     cin.tie(NULL);
59 | 
60 |     ll n;
61 |     cin >> n;
62 |     for (ll i = 0; i < n - 1; i++)
63 |     {
64 |         ll u, v;
65 |         cin >> u >> v;
66 |         graph[u].push_back(v);
67 |         graph[v].push_back(u);
68 |         
69 |     }
70 |     
71 |     dfs(1);
72 |     vec.push_back({1,0});
73 |     sort(vec.begin(),vec.end());
74 |     auto it=vec.end();
75 |     it--;
76 |     v1=it->second;
77 |     
78 |     mxx=0;
79 |     visited.assign(n+1,false);
80 |     // cout<<v1<<" "<<v2<<endl;
81 |     dfss(v1);
82 |     
83 |     cout << ans << endl;
84 | 
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/CSES TREES/1132-TreeDistance-I(method -1).cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | 
 10 | /*
 11 | Basically approach is about finding two end points of diameter of tree and then finding distance of every node
 12 | from both end points and from which endpoint ditance is max that will be considered.
 13 | 
 14 | 
 15 | ans[i]=max(dis(end1,i),dis(end2,i));
 16 | */
 17 | 
 18 | 
 19 | #include <bits/stdc++.h>
 20 | using namespace std;
 21 | 
 22 | #define ll unsigned long long
 23 | #define mod 1000000007
 24 | 
 25 | vector<ll> graph[200005];
 26 | vector<bool> visited(200005, false);
 27 | ll mxx=0;
 28 | 
 29 | ll prv=0;
 30 | ll v1,v2;
 31 | 
 32 | vector<pair<ll,ll>> vec;
 33 | void dfs(ll v)
 34 | {
 35 |     visited[v] = true;
 36 |     
 37 | 
 38 |     bool flag=false;
 39 |     for (auto u : graph[v])
 40 |     {
 41 |         if (!visited[u])
 42 |         {
 43 |             mxx++;
 44 |             if(mxx>prv){
 45 |                 prv=mxx;
 46 |                 v1=u;
 47 |             }
 48 |             dfs(u);
 49 |             mxx--;
 50 |         }
 51 |     }
 52 | }
 53 | 
 54 | 
 55 | 
 56 | vector<ll> ans(200005,0);
 57 | 
 58 | 
 59 | 
 60 | 
 61 | 
 62 | 
 63 | void dfss(ll v){
 64 |     visited[v]=true;
 65 |     for(auto u:graph[v]){
 66 |         if(!visited[u]){
 67 |             mxx++;
 68 |             ans[u]=max(ans[u],mxx);
 69 |             dfss(u);
 70 |             mxx--;
 71 |         }
 72 |     }
 73 | }
 74 | 
 75 | 
 76 | 
 77 | int main()
 78 | {
 79 |     ios_base::sync_with_stdio(false);
 80 |     cin.tie(NULL);
 81 | 
 82 |     ll n;
 83 |     cin >> n;
 84 |     for (ll i = 0; i < n - 1; i++)
 85 |     {
 86 |         ll u, v;
 87 |         cin >> u >> v;
 88 |         graph[u].push_back(v);
 89 |         graph[v].push_back(u);
 90 |         
 91 |     }
 92 |     
 93 |     dfs(1);
 94 |     ll stp=v1;
 95 |     mxx=0;
 96 |     prv=0;
 97 |     visited.assign(n+1,false);
 98 |     dfs(stp);
 99 |     ll endp=v1;
100 |     visited.assign(n+1,false);
101 |     dfss(stp);
102 |     visited.assign(n+1,false);
103 |     // cout<<stp<<" "<<endp<<endl;
104 |     dfss(endp);
105 | 
106 |     for(ll i=1;i<=n;i++){
107 |         cout<<ans[i]<<" ";
108 |     }
109 |     cout<<endl;
110 | 
111 |     return 0;
112 | }
113 | 


--------------------------------------------------------------------------------
/CSES TREES/1133-TreeDistanceII.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | basically approach is:
 11 | 1. find total sum of distance from node 1 to all other nodes.
 12 | 2. now will count total node in a subtree for each node (child[i]=ith node has total no of childers+ 1);
 13 | 3. now we can say for a par and a node u;
 14 | ans[u]=ans[par]-(child[i])+(n-child[i]);
 15 | we precalculate ans[1] so we can start traversal from there;
 16 | bcs if we move towards u then we can see its distance from its childern reduced by 1 and from other nodes increased by +1;
 17 | 
 18 | */
 19 | 
 20 | 
 21 | #include <bits/stdc++.h>
 22 | using namespace std;
 23 | 
 24 | #define ll unsigned long long
 25 | #define mod 1000000007
 26 | 
 27 | vector<ll> graph[200005];
 28 | vector<bool> visited(200005, false);
 29 | vector<ll> ans(200005,0);
 30 | ll n;
 31 | ll sm=0;
 32 | ll mxx=0;
 33 | void dfs(ll v)
 34 | {
 35 |     visited[v] = true;
 36 |     
 37 |     for (auto u : graph[v])
 38 |     {
 39 |         if (!visited[u])
 40 |         {
 41 |             mxx++;
 42 |             sm+=mxx;
 43 |             dfs(u);
 44 |             mxx--;
 45 |         }
 46 |     }
 47 | }
 48 | 
 49 | 
 50 | 
 51 | vector<ll> child(200005,1);
 52 | 
 53 | 
 54 | void dfs1(ll v){
 55 |     visited[v]=true;
 56 |     for(auto u:graph[v]){
 57 |         if(!visited[u]){
 58 |             dfs1(u);
 59 |             child[v]+=child[u];
 60 |         }
 61 |     }
 62 | }
 63 | 
 64 | 
 65 | void ansdfs(ll v){
 66 |     visited[v]=true;
 67 |     for(auto u:graph[v]){
 68 |         if(!visited[u]){
 69 | 
 70 |             ans[u]=(ans[v]-2*child[u]+n);
 71 |             ansdfs(u);
 72 |         }
 73 |     }
 74 | 
 75 | }
 76 | 
 77 | 
 78 | 
 79 | int main()
 80 | {
 81 |     ios_base::sync_with_stdio(false);
 82 |     cin.tie(NULL);
 83 | 
 84 |     // ll n;
 85 |     cin >> n;
 86 |     for (ll i = 0; i < n - 1; i++)
 87 |     {
 88 |         ll u, v;
 89 |         cin >> u >> v;
 90 |         graph[u].push_back(v);
 91 |         graph[v].push_back(u);
 92 |         
 93 |     }
 94 |     dfs(1);
 95 |     ans[1]=sm;
 96 |     visited.assign(n+1,false);
 97 |     dfs1(1);
 98 |     visited.assign(n+1,false);
 99 |     ansdfs(1);
100 |     for(ll i=1;i<=n;i++){
101 |         cout<<ans[i]<<" ";
102 |     }
103 |     cout<<endl;
104 | 
105 |     return 0;
106 | }
107 | 


--------------------------------------------------------------------------------
/CSES TREES/1135-DistanceQueries.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | in LCA method we are looking for LCA now we are basically looking for-
 11 | dis(LCA,u)+dis(LCA,v);
 12 | we had already equal level(u)==level(v);
 13 | dis+=(2*(LCA,u));
 14 | return dis;
 15 | */
 16 | 
 17 | #include <bits/stdc++.h>
 18 | using namespace std;
 19 | 
 20 | #define ll long long
 21 | #define mod 1000000007
 22 | ll n,q;
 23 | 
 24 | 
 25 | vector<ll> graph[200005];
 26 | vector<ll> par(200005,-1);
 27 | 
 28 | ll lvl=1;
 29 | vector<ll> level(200005,0);
 30 | 
 31 | ll dp[200005][21];
 32 | 
 33 | void dfs(ll v){
 34 |     level[v]=lvl;
 35 |     // cout<<v<<endl;
 36 | 
 37 |     for(auto u:graph[v]){
 38 |         if(level[u]==0){
 39 |             dp[u][0]=v;
 40 |             lvl++;
 41 |             dfs(u);
 42 |             lvl--;
 43 |         }
 44 |     }
 45 |     
 46 | 
 47 | }
 48 | 
 49 | 
 50 | ll lca(ll tempu,ll tempv){
 51 |     // cout<<level[u]<<" "<<level[v]<<endl;
 52 |     ll u=tempu,v=tempv;
 53 |     ll an=abs(level[u]-level[v]);
 54 |     if(level[u]<level[v]){
 55 |         ll k=level[v]-level[u];
 56 |         // cout<<k<<endl;
 57 |         for(ll i=20;i>=0;i--){
 58 |             if(((k>>i)&1)){
 59 |                 // cout<<i<<"i"<<endl;
 60 |                 v=dp[v][i];
 61 |             }
 62 |             
 63 |         }
 64 | 
 65 |     }else if(level[u]>level[v]){
 66 |         ll k=level[u]-level[v];
 67 |         for(ll i=20;i>=0;i--){
 68 |             if(((k>>i)&1)){
 69 |                 u=dp[u][i];
 70 |             }
 71 |             
 72 |         }
 73 |     }
 74 |     // cout<<an<<endl;
 75 |     // cout<<u<<" "<<v<<endl;
 76 |     if(u==v){
 77 |         // cout<<"UES"<<endl;
 78 |         return an;
 79 |     }
 80 |     ll ans=0;
 81 |     ll pre=0;
 82 |     ll anss=INT_MAX;
 83 |     for(ll i=20;i>=0;i--){
 84 |         if(dp[u][i]==dp[v][i]){
 85 |             // ans=dp[u][i];
 86 |             ans+=(1<<i);
 87 |             ans-=pre;
 88 |             anss=min(anss,ans);
 89 | 
 90 |             pre=(1<<i);
 91 |         }else{
 92 |             ans-=pre;
 93 |             ans+=(1<<i);
 94 |             pre=0;
 95 |             u=dp[u][i];
 96 |             v=dp[v][i];
 97 |         }
 98 |     }
 99 |     anss*=2;
100 |     anss+=an;
101 |     return anss;
102 | }
103 | 
104 | 
105 | void binlift(){
106 |     for(ll i=1;i<=20;i++){
107 |         for(ll j=1;j<=n;j++){
108 |             dp[j][i]=dp[dp[j][i-1]][i-1];
109 | 
110 |         }
111 |     }  
112 |      
113 | }
114 | 
115 | 
116 | 
117 | 
118 | 
119 | int main()
120 | {
121 |     ios_base::sync_with_stdio(false);
122 |     cin.tie(NULL);
123 |     cin>>n>>q;
124 |     // dp[1][0]=-1;
125 |     memset(dp,0,sizeof(dp));
126 |     for(ll i=0;i<n-1;i++){
127 |         ll u,v;
128 |         cin>>u>>v;
129 |         // dp[v][0]=u;
130 |         // dp[u][0]=v;
131 |         graph[u].push_back(v);
132 |         graph[v].push_back(u);
133 |     }
134 | 
135 | 
136 |     dfs(1);
137 |     binlift();
138 | 
139 | 
140 |     // for(ll i=1;i<=n;i++){
141 |     //     cout<<dp[i][0]<<" ";
142 |     // }
143 |     // cout<<endl;
144 | 
145 | 
146 |     // for(ll i=1;i<=n;i++){
147 |         // cout<<level[i]<<" ";
148 |     // }
149 |     // cout<<endl;
150 |     while(q--){
151 |         ll u,v;
152 |         cin>>u>>v;
153 |         cout<<lca(u,v)<<endl;;
154 |     }
155 | 
156 | 
157 | 
158 |     return 0;
159 | }
160 | 


--------------------------------------------------------------------------------
/CSES TREES/1136-CountingPaths.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 |  
  9 | // LCA 
 10 | 
 11 | 
 12 | /*
 13 |     How to Approach?
 14 |     basically we know there is only one path in a tree to one node to other node if we can traverse a node once....
 15 |     
 16 |     how many nodes will affected by their path?
 17 |     node from LCA(u,v) to u and LCA(u,v) to v;
 18 |     
 19 |     increase the value of node u and v each by 1
 20 |     and decrease the value of lca by 2;
 21 |     
 22 |     now will store sum of nodes's subtree by using dfs;
 23 |     after it remeber to increase all lca values by 1;
 24 |     
 25 | 
 26 |       
 27 | 
 28 | */
 29 |  
 30 | #include <bits/stdc++.h>
 31 | using namespace std;
 32 |  
 33 | #define ll long long
 34 | #define mod 1000000007
 35 | ll n,q;
 36 |  
 37 |  
 38 | vector<ll> graph[200005];
 39 | vector<ll> par(200005,-1);
 40 | vector<ll> ans(200005,0);
 41 | vector<bool> visited(200005,false);
 42 |  
 43 | ll lvl=1;
 44 | vector<ll> level(200005,0);
 45 |  
 46 | ll dp[200005][21];
 47 | 
 48 | vector<ll> check(200005,0);
 49 |  
 50 | void dfs(ll v){
 51 |     level[v]=lvl;
 52 |     // cout<<v<<endl;
 53 |  
 54 |     for(auto u:graph[v]){
 55 |         if(level[u]==0){
 56 |             dp[u][0]=v;
 57 |             lvl++;
 58 |             dfs(u);
 59 |             lvl--;
 60 |         }
 61 |     }
 62 |     
 63 |  
 64 | }
 65 | 
 66 | 
 67 | void dfs1(ll v){
 68 |     visited[v]=true;
 69 |     for(auto u:graph[v]){
 70 |         if(!visited[u]){
 71 |             dfs1(u);
 72 | 
 73 |             ans[v]+=ans[u];
 74 |         }
 75 |     }
 76 | 
 77 | 
 78 | }
 79 |  
 80 |  
 81 | ll lca(ll tempu,ll tempv){
 82 |     ll u=tempu,v=tempv;
 83 |     ll an=abs(level[u]-level[v]);
 84 |     if(level[u]<level[v]){
 85 |         ll k=level[v]-level[u];
 86 |         for(ll i=20;i>=0;i--){
 87 |             if(((k>>i)&1)){
 88 |                 v=dp[v][i];
 89 |             }
 90 |             
 91 |         }
 92 |  
 93 |     }else if(level[u]>level[v]){
 94 |         ll k=level[u]-level[v];
 95 |         for(ll i=20;i>=0;i--){
 96 |             if(((k>>i)&1)){
 97 |                 u=dp[u][i];
 98 |             }
 99 |             
100 |         }
101 |     }
102 | 
103 |     if(u==v){
104 |         return u;
105 |     }
106 |     ll ans=0;
107 |     ll pre=0;
108 |     ll anss=INT_MAX;
109 |     for(ll i=20;i>=0;i--){
110 |         if(dp[u][i]==dp[v][i]){
111 |             // ans=dp[u][i];
112 |             ans=dp[u][i];
113 |         }else{
114 |             u=dp[u][i];
115 |             v=dp[v][i];
116 |         }
117 |     }
118 |     return ans;
119 | }
120 |  
121 |  
122 | void binlift(){
123 |     for(ll i=1;i<=20;i++){
124 |         for(ll j=1;j<=n;j++){
125 |             dp[j][i]=dp[dp[j][i-1]][i-1];
126 |         }
127 |     }  
128 |      
129 | }
130 |  
131 |  
132 |  
133 |  
134 |  
135 | int main()
136 | {
137 |     ios_base::sync_with_stdio(false);
138 |     cin.tie(NULL);
139 |     cin>>n>>q;
140 |     // dp[1][0]=-1;
141 |     memset(dp,0,sizeof(dp));
142 |     for(ll i=0;i<n-1;i++){
143 |         ll u,v;
144 |         cin>>u>>v;
145 |         // dp[v][0]=u;
146 |         // dp[u][0]=v;
147 |         graph[u].push_back(v);
148 |         graph[v].push_back(u);
149 |     }
150 |  
151 |  
152 |     dfs(1);
153 |     binlift();
154 |  
155 |     while(q--){
156 |         ll u,v;
157 |         cin>>u>>v;
158 |         ll val=lca(u,v);
159 |         // cout<<u<<" "<<v<<endl;
160 |         // cout<<val<<endl;
161 |         ans[val]-=2;
162 |         // check[val]=true;
163 |         check[val]++;
164 |         ans[u]++;
165 |         ans[v]++;
166 |     }
167 |     // for(ll i=1;i<=n;i++){
168 |     //     cout<<ans[i]<<" ";
169 |     // }
170 |     // cout<<endl;
171 |     dfs1(1);
172 | 
173 | 
174 |     for(ll i=1;i<=n;i++){
175 |         cout<<ans[i]+check[i]<<" ";
176 |     }
177 |     cout<<endl;
178 |  
179 |  
180 |  
181 |     return 0;
182 | }
183 | 


--------------------------------------------------------------------------------
/CSES TREES/1137-SubtreeQueries.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 |  
  9 | /*
 10 | basically approach is simple firslty we stored dfs traversal into a vector now we know queries;
 11 | 
 12 | query1(i,val):- update ith node val;
 13 | 
 14 | query2(i):-> sum of all the  node in subtree;  which will be equal to :- sum(vec[stnode],vec[stnode+child[stnode]);
 15 | where child[i] denotes the element in a subtree of ith node;
 16 | 
 17 | now we can constuct a segment tree to answer the queries;
 18 | 
 19 | */
 20 |  
 21 | #include <bits/stdc++.h>
 22 | using namespace std;
 23 |  
 24 | #define ll long long
 25 | #define mod 1000000007
 26 | ll n,q;
 27 | 
 28 | vector<ll> arr(200005,0);
 29 | 
 30 | vector<ll> graph[200005];
 31 | 
 32 | vector<ll> child(200005,1);
 33 | vector<bool> visited(200005,false);
 34 | 
 35 | vector<ll> vec;
 36 | vector<ll> pos(200005,0);
 37 | 
 38 | 
 39 | void dfs(ll v){
 40 |     visited[v]=true;
 41 |     vec.push_back(v);
 42 |     for(auto u:graph[v]){
 43 |         if(!visited[u]){
 44 |             dfs(u);
 45 |             child[v]+=child[u];
 46 |         }
 47 |     }
 48 | } 
 49 | 
 50 | 
 51 | 
 52 | 
 53 | vector<ll> seg(800005,0);
 54 | 
 55 | 
 56 | void st(ll i,ll val,ll x,ll l,ll r){
 57 |     if(r-l==1){
 58 |         seg[x]=val;
 59 |         return ;
 60 |     }
 61 | 
 62 |     ll mid=(l+r)/2;
 63 |     if(i<mid){
 64 |         st(i,val,2*x+1,l,mid);
 65 |     }else{
 66 |         st(i,val,2*x+2,mid,r);
 67 |     }
 68 | 
 69 |     seg[x]=seg[2*x+1]+seg[2*x+2];
 70 | }
 71 | 
 72 | ll sum(ll l,ll r,ll x,ll lf,ll rf){
 73 |     if(lf>=l && rf<=r){
 74 |         return seg[x];
 75 |     }else if(lf>=r || rf<=l){
 76 |         return 0;
 77 |     }
 78 |     ll mid=(lf+rf)/2;
 79 |     return sum(l,r,2*x+1,lf,mid)+sum(l,r,2*x+2,mid,rf);
 80 | }
 81 |  
 82 | 
 83 | 
 84 | int main()
 85 | {
 86 |     ios_base::sync_with_stdio(false);
 87 |     cin.tie(NULL);
 88 |     cin>>n>>q;
 89 | 
 90 |     for(ll i=0;i<n;i++){
 91 |         cin>>arr[i];
 92 | 
 93 |     }
 94 | 
 95 | 
 96 |     for(ll i=0;i<n-1;i++){
 97 |         ll u,v;
 98 |         cin>>u>>v;
 99 |         u--;
100 |         v--;
101 |         graph[u].push_back(v);
102 |         graph[v].push_back(u);
103 |     }
104 |     dfs(0);
105 | 
106 |     for(ll i=0;i<n;i++){
107 |         pos[vec[i]]=i;
108 |         st(i,arr[vec[i]],0,0,n);
109 | 
110 |     }
111 |     // for(auto i:vec){
112 |     //     cout<<i<<" ";
113 |     // }
114 |     // cout<<endl;
115 | 
116 |     while(q--){
117 |         ll tp;
118 |         cin>>tp;
119 |         if(tp==1){
120 |             ll s,x;
121 |             cin>>s>>x;
122 |             s--;
123 |             s=pos[s];
124 |             st(s,x,0,0,n);
125 |         }else{
126 |             ll s;
127 |             cin>>s;
128 |             s--;
129 | 
130 |             ll l=pos[s];
131 |             ll r=l+child[s];
132 |             // cout<<l<<" "<<r<<endl;
133 |             // cout<<arr[l]<<" "<<arr[r-1]<<endl;
134 |             ll ans=sum(l,r,0,0,n);
135 |             cout<<ans<<endl;
136 |         }
137 |     }
138 |  
139 |     return 0;
140 | }
141 | 


--------------------------------------------------------------------------------
/CSES TREES/1674-subordinates.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 | 
15 | vector<ll> graph[200005];
16 | 
17 | vector<ll> ans(200005,0);
18 | 
19 | vector<bool> visited(200005,false);
20 | 
21 | 
22 | void dfs(ll v){
23 |     visited[v]=true;
24 |     ll an=0;
25 |     for(auto u:graph[v]){
26 |         if(!visited[u]){
27 |             dfs(u);
28 |         }
29 |         an+=(ans[u]+1);
30 |     }
31 |     ans[v]=an;
32 | }
33 | 
34 | 
35 | 
36 | int main()
37 | {
38 |     ios_base::sync_with_stdio(false);
39 |     cin.tie(NULL);
40 |     ll n;
41 |     cin>>n;
42 |     ll arr[n+1];
43 |     arr[1]=-1;
44 |     for(ll i=2;i<=n;i++){
45 |         cin>>arr[i];
46 |     }
47 |     // cout<<"YES"<<endl;
48 | 
49 | 
50 |     for(ll i=2;i<=n;i++){
51 |         graph[arr[i]].push_back(i);
52 |     }
53 | 
54 |     dfs(1);
55 |     for(ll i=1;i<=n;i++){
56 |         cout<<ans[i]<<" ";
57 |     }
58 |     cout<<endl;
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 |    
66 |     
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/CSES TREES/1687 company-queries1.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | Binary  lifting.
 11 | https://cp-algorithms.com/graph/lca_binary_lifting.html
 12 | 
 13 | https://www.youtube.com/watch?v=FAfSArGC8KY&list=PLb3g_Z8nEv1j_BC-fmZWHFe6jmU_zv-8s&index=7&ab_channel=KartikArora
 14 | 
 15 | will suggest you to not watch complete video just take idea about binary lifting and try to implement by your self it is just same as sparse table.
 16 | */
 17 |  
 18 | #include <bits/stdc++.h>
 19 | using namespace std;
 20 |  
 21 | #define ll long long
 22 | #define mod 1000000007
 23 | 
 24 | vector<ll> graph[200005];
 25 | 
 26 | vector<ll> ans(200005,0);
 27 | 
 28 | vector<bool> visited(200005,false);
 29 | 
 30 | ll dp[200005][20];
 31 | 
 32 | ll n,q;
 33 | 
 34 | 
 35 | 
 36 | void binlift(){
 37 |     for(ll i=1;i<20;i++){
 38 |         for(ll j=1;j<=n;j++){
 39 |             if(dp[j][i-1]==-1){
 40 |                 dp[j][i]=-1;
 41 |                 continue;
 42 |             }
 43 |             dp[j][i]=dp[dp[j][i-1]][i-1];
 44 |         }
 45 |     }
 46 | 
 47 | 
 48 | }
 49 | 
 50 | 
 51 | ll query(ll x,ll k){
 52 |     ll prev=x;
 53 |     for(ll i=20;i>=0;i--){
 54 |         if((k>>i)&1){
 55 |             // cout<<i<<"i"<<endl;
 56 |             prev=dp[prev][i];
 57 |             if(prev==-1){
 58 |                 break;
 59 |             }
 60 | 
 61 |         }
 62 |     }    
 63 |     return prev;
 64 | }
 65 | 
 66 | 
 67 | 
 68 | int main()
 69 | {
 70 |     ios_base::sync_with_stdio(false);
 71 |     cin.tie(NULL);
 72 |     cin>>n>>q;
 73 |     ll arr[n+1];
 74 |     arr[1]=-1;
 75 |     memset(dp,-1,sizeof(dp));
 76 |     dp[1][0]=-1;
 77 |     for(ll i=2;i<=n;i++){
 78 |         cin>>arr[i];
 79 |         dp[i][0]=arr[i];
 80 |         
 81 |     }
 82 | 
 83 |     // for(ll i=1;i<=n;i++)
 84 |     // {
 85 |     //     for(ll j=0;j<=3;j++){
 86 |     //         cout<<dp[i][j]<<" ";
 87 |     //     }
 88 |     //     cout<<endl;
 89 |     // }
 90 |     // cout<<"YES"<<endl;
 91 | 
 92 |     binlift();
 93 |     while(q--){
 94 |         ll x,k;
 95 |         cin>>x>>k;
 96 | 
 97 |         ll ans=query(x,k);
 98 |         cout<<ans<<endl;
 99 |     }
100 | 
101 | 
102 | 
103 | 
104 | 
105 | 
106 | 
107 | 
108 |    
109 |     
110 |     return 0;
111 | }
112 | 


--------------------------------------------------------------------------------
/CSES TREES/1688-Company Queries II.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | // LCA 
 10 | 
 11 | #include <bits/stdc++.h>
 12 | using namespace std;
 13 | 
 14 | #define ll long long
 15 | #define mod 1000000007
 16 | ll n,q;
 17 | 
 18 | 
 19 | vector<ll> graph[200005];
 20 | 
 21 | ll lvl=1;
 22 | vector<ll> level(200005,0);
 23 | 
 24 | ll dp[200005][21];
 25 | 
 26 | void dfs(ll v){
 27 |     level[v]=lvl;
 28 |     // cout<<v<<endl;
 29 | 
 30 |     for(auto u:graph[v]){
 31 |         if(level[u]==0){
 32 |             lvl++;
 33 |             dfs(u);
 34 |             lvl--;
 35 |         }
 36 |     }
 37 |     
 38 | 
 39 | }
 40 | 
 41 | 
 42 | ll lca(ll tempu,ll tempv){
 43 |     // cout<<level[u]<<" "<<level[v]<<endl;
 44 |     ll u=tempu,v=tempv;
 45 |     if(level[u]<level[v]){
 46 |         ll k=level[v]-level[u];
 47 |         // cout<<k<<endl;
 48 |         for(ll i=20;i>=0;i--){
 49 |             if(((k>>i)&1)){
 50 |                 // cout<<i<<"i"<<endl;
 51 |                 v=dp[v][i];
 52 |             }
 53 |             
 54 |         }
 55 | 
 56 |     }else if(level[u]>level[v]){
 57 |         ll k=level[u]-level[v];
 58 |         for(ll i=20;i>=0;i--){
 59 |             if(((k>>i)&1)){
 60 |                 u=dp[u][i];
 61 |             }
 62 |             
 63 |         }
 64 |     }
 65 |     if(u==v){
 66 |         return u;
 67 |     }
 68 |     ll ans=0;
 69 | 
 70 |     for(ll i=20;i>=0;i--){
 71 |         if(dp[u][i]==dp[v][i]){
 72 |             ans=dp[u][i];
 73 |         }else{
 74 |             u=dp[u][i];
 75 |             v=dp[v][i];
 76 |         }
 77 |     }
 78 |     return ans;
 79 | }
 80 | 
 81 | 
 82 | void binlift(){
 83 |     for(ll i=1;i<=20;i++){
 84 |         for(ll j=1;j<=n;j++){
 85 |             dp[j][i]=dp[dp[j][i-1]][i-1];
 86 | 
 87 |         }
 88 |     }  
 89 |      
 90 | }
 91 | 
 92 | 
 93 | 
 94 | 
 95 | 
 96 | int main()
 97 | {
 98 |     ios_base::sync_with_stdio(false);
 99 |     cin.tie(NULL);
100 |     cin>>n>>q;
101 |     // dp[1][0]=-1;
102 |     memset(dp,0,sizeof(dp));
103 |     for(ll i=2;i<=n;i++){
104 |         ll x;
105 |         cin>>x;
106 |         dp[i][0]=x;
107 |         graph[x].push_back(i);
108 |         // graph[x].push_back(i);
109 |     }
110 | 
111 |     binlift();
112 | 
113 | 
114 |     // cout<<"U";
115 |     dfs(1);
116 |     // cout<<"U";
117 | 
118 |     // for(ll i=1;i<=n;i++){
119 |         // cout<<level[i]<<" ";
120 |     // }
121 |     // cout<<endl;
122 |     while(q--){
123 |         ll u,v;
124 |         cin>>u>>v;
125 |         cout<<lca(u,v)<<endl;
126 |     }
127 | 
128 | 
129 | 
130 |     return 0;
131 | }
132 | 


--------------------------------------------------------------------------------
/DP/1.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | #define mod 1000000007
14 | 
15 | ll dp[40005][500];
16 | 
17 | int main()
18 | {
19 |     ll t;
20 |     cin >> t;
21 |     ll N = 40005;
22 |     vector<ll> vec;
23 |     vector<ll> ans(N, 0);
24 |     vector<bool> pali(N, false);
25 |     vec.push_back(0);
26 |     for (ll i = 1; i < N; i++)
27 |     {
28 |         ll temp = i;
29 |         bool flag = false;
30 |         vector<ll> bits;
31 |         while (temp != 0)
32 |         {
33 |             ll val = temp % 10;
34 |             bits.push_back(val);
35 |             temp /= 10;
36 |         }
37 | 
38 |         bool check = true;
39 |         ll sz = bits.size();
40 |         for (ll i = 0; i < (sz / 2); i++)
41 |         {
42 |             if (bits[i] != bits[sz - i - 1])
43 |             {
44 |                 check = false;
45 |                 break;
46 |             }
47 |         }
48 |         pali[i] = check;
49 |         if (check)
50 |         {
51 |             vec.push_back(i);
52 |         }
53 |     }
54 |     ll siz = vec.size();
55 |     // dp[0][0] = 1;
56 |     // cout << "YES" << endl;
57 |     // dp[1][1] = 1;
58 |     // siz=400;
59 |     // cout << siz << endl;
60 | 
61 |     for (int j = 1; j <= siz; j++)
62 |         dp[0][j] = 1;
63 |     for (int i = 1; i < N; i++)
64 |     {
65 |         dp[i][0] = 0;
66 |         for (int j = 1; j <= siz; j++)
67 |         {
68 |             if (vec[j] <= i)
69 |                 dp[i][j] = (dp[i][j - 1] + dp[i - vec[j]][j]) % mod;
70 |             else
71 |                 dp[i][j] = dp[i][j - 1];
72 |         }
73 |     }
74 |     // cout << "YES" << endl;
75 | 
76 |     while (t--)
77 |     {
78 |         ll n;
79 |         cin >> n;
80 |         cout << dp[n][siz-1] << endl;
81 |     }
82 |     return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/DP/2.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // waiting....
10 | 
11 | #include<bits/stdc++.h>
12 | using namespace std;
13 | 
14 | #define ll long long
15 | 
16 | int main(){
17 |     ll t;
18 |     cin>>t;
19 |     while(t--){
20 |         string s;
21 |         cin>>s;
22 |         ll n=s.length();
23 |         vector<ll> dp(n+1,0);
24 |         vector<ll> vec(26,-1);
25 |         for(ll i=n-1;i>=0;i--){
26 |             ll val=(ll)(s[i])-(ll)('a');
27 |             ll in=vec[val];
28 |             ll an=0;
29 |             if(in!=-1)
30 |             {
31 |                 an=dp[in+1];
32 |             }else{
33 |                 an=-2;
34 |             }
35 | 
36 |             dp[i]=max(dp[i+1],an+2);
37 |             vec[val]=i;
38 |             
39 |         }
40 | 
41 | 
42 |         cout<<(n-dp[0])<<endl;
43 | 
44 |     }
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/DP/3.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // waiting....
10 | 
11 | #include<bits/stdc++.h>
12 | using namespace std;
13 | 
14 | #define ll long long
15 | #define mod 998244353
16 | 
17 | 
18 | ll add(ll x,ll y){
19 |     return (x%mod + y%mod)%mod;
20 | }
21 | 
22 | ll mul(ll x,ll y){
23 |     return ((x%mod)*(y%mod))%mod;
24 | }
25 | 
26 | 
27 | ll c[1001][1001];
28 | 
29 | void cr(){
30 |     for(ll i=0;i<=1000;i++){
31 |         c[i][0]=1;
32 |     }
33 | 
34 |     for(ll i=1;i<=1000;i++){
35 |         for(ll j=1;j<=i;j++){
36 |             c[i][j]=add(c[i-1][j],c[i-1][j-1]);
37 |         }
38 |     }
39 | }
40 | 
41 | 
42 | 
43 | int main(){
44 |     cr();
45 |     ll n;
46 |     cin>>n;
47 |     ll arr[n];
48 |     for(ll i=0;i<n;i++){
49 |         cin>>arr[i];
50 |     }
51 |     // cout<<c[4][5]<<endl;
52 |     vector<ll> dp(n+1,0);
53 | 
54 |     ll mx=0;
55 | 
56 |     dp[n]=1;
57 |     for(ll i=n-1;i>=0;i--){
58 |         ll k=arr[i];
59 | 
60 | 
61 |         if(k<=0){
62 |             continue;
63 |         }
64 |        
65 | 
66 | 
67 |         // ll an=1;
68 | 
69 |         // dp[i]=add(dp[i],(c[n-i-1][k]));
70 |         for(ll j=i+k+1;j<=n;j++){
71 |             dp[i]=add(dp[i],mul(c[j-i-1][k],(dp[j])));
72 |         }
73 |     }
74 | 
75 | 
76 |     ll ans=0;
77 |     for(ll i=0;i<=n-1;i++){
78 |         ans=add(ans,dp[i]);
79 |         // cout<<dp[i]<<" ";
80 |     }
81 |     // cout<<endl;
82 |     cout<<ans<<endl;
83 |     return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/DP/4.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // waiting....
10 | 
11 | #include<bits/stdc++.h>
12 | using namespace std;
13 | 
14 | #define ll long long
15 | 
16 | ll DP[105][10005]={INT_MAX};
17 | 
18 | ll dp(ll n,ll arr[],ll brr[],ll i,ll s,ll sum){
19 |     if(i>=n){
20 |         return s*s +(sum-s)*(sum-s);
21 |     }
22 |     if(DP[i][s]!=INT_MAX){
23 |         // cout<<DP[i][s]<<endl;
24 |         return DP[i][s];
25 |     }
26 |     // cout<<"yES"<<endl;
27 |     return DP[i][s]= min(dp(n,arr,brr,i+1,s+arr[i],sum),dp(n,arr,brr,i+1,s+brr[i],sum));
28 | 
29 |         
30 |     
31 | 
32 | 
33 | }
34 | 
35 | int main(){
36 |     ll t;
37 |     cin>>t;
38 |     while(t--){
39 |         ll n;
40 |         cin>>n;
41 |         ll arr[n],brr[n];
42 |         ll ans=0;
43 |         ll mx=-1;
44 |         ll ina=-1;
45 |         ll inb=-1;
46 |         ll sum=0;
47 |         
48 |         for(ll i=0;i<n;i++){
49 |             cin>>arr[i];
50 |             sum+=arr[i];
51 |             ans+=(arr[i]*arr[i])*(n-2);
52 |         }
53 |         for(ll i=0;i<n;i++){
54 |             cin>>brr[i];
55 |             sum+=brr[i];
56 |             ans+=(brr[i]*brr[i])*(n-2);
57 | 
58 |         }
59 |         for(ll i=0;i<=n;i++){
60 |             for(ll j=0;j<=sum+2;j++){
61 |                 DP[i][j]=INT_MAX;
62 |             }
63 |         }
64 | 
65 |         if(n==1){
66 |             cout<<"0"<<endl;
67 |             continue;
68 |         }
69 | 
70 |         ans+=dp(n,arr,brr,0,0,sum);
71 |         cout<<ans<<endl;
72 |         
73 | 
74 | 
75 |         
76 | 
77 |     }
78 |     return 0;
79 | }
80 |  
81 | 


--------------------------------------------------------------------------------
/DP/5.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // waiting....
10 | 
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 | 
14 | #define ll long long
15 | 
16 | ll solve(ll k, ll coins[], ll crr[], ll n)
17 | {
18 | 
19 |     ll dp[k + 1];
20 |     memset(dp, 0, sizeof(dp));
21 | 
22 |     for (ll i = 1; i <= n; i++)
23 |     {
24 |         for (ll w = k; w >= 0; w--)
25 |         {
26 | 
27 |             if (coins[i - 1] <= w)
28 | 
29 |                 dp[w] = max(dp[w], dp[w - coins[i - 1]] + crr[i - 1]);
30 |         }
31 |     }
32 |     return dp[k];
33 | }
34 | 
35 | 
36 | int main()
37 | {
38 |     ll t;
39 |     cin >> t;
40 |     ll cost[1025];
41 |     memset(cost,1000000,sizeof(cost));
42 |     cost[1] = 0, cost[2] = 1;
43 |     for (int i = 3; i < 1024; i++) {
44 |         for (int j = i - 1; j >= 1; j--) {
45 |             int z = i - j;
46 |             int x = j / z;
47 |             if (x > 0 && (j + (j / x)) == i) {
48 |                 cost[i] = min(cost[i], 1 + cost[j]);
49 |             }
50 |         }
51 |     }
52 |     // for(ll i=1;i<=10;i++)
53 |     // {
54 |     //     cout<<cost[i]<<" ";
55 |     // }
56 | 
57 |     while (t--)
58 |     {
59 |         ll n, k;
60 |         cin >> n >> k;
61 |         // ll arr[n];
62 |         ll brr[n];
63 |         ll crr[n];
64 | 
65 |         for (ll i = 0; i < n; i++)
66 |         {
67 |             cin >> brr[i];
68 |         }
69 |         for (ll i = 0; i < n; i++)
70 |         {
71 |             cin >> crr[i];
72 |         }
73 | 
74 |         ll coins[n];
75 |         // memset(coins, 0, sizeof(coins));
76 |         ll vlll = 0;
77 |         for (ll i = 0; i < n; i++)
78 |         {
79 |             coins[i]=cost[brr[i]];
80 |             vlll+=(cost[brr[i]]);
81 |         }
82 |         k = min(k, vlll);
83 | 
84 |         // cout<<endl;
85 |         // for (ll i = 0; i < n; i++)
86 |         // {
87 |         //     cout << coins[i] << " ";
88 |         // }
89 |         // cout << endl;
90 |         ll ans = solve(k, coins, crr, n);
91 |         cout << ans << endl;
92 |     }
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/DP/6.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // sab moh maya hai....
 6 | 
 7 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | #define mod 1000000007
14 | 
15 | ll mulm(ll a,ll b){
16 |     return ((a%mod)*(b%mod))%mod;
17 | }
18 | 
19 | ll summ(ll a,ll b){
20 |     return (a%mod + b%mod)%mod;
21 | }
22 | 
23 | long long binpow(long long a, long long b) {
24 |     long long res = 1;
25 |     while (b > 0) {
26 |         if (b & 1)
27 |             res = mulm(res , a);
28 |         a = mulm(a,a);
29 |         b >>= 1;
30 |     }
31 |     return res;
32 | }
33 | 
34 | 
35 | int main(){
36 |     ll t;
37 |     cin>>t;
38 |     while(t--){
39 |         ll n,k;
40 |         cin>>n>>k;
41 |         if(k==0){
42 |             cout<<"1"<<endl;
43 |             continue;
44 |         }
45 |         if(n%2==1){
46 | 
47 | 
48 |             ll ans=1;
49 |             
50 |             ans=mulm(ans,((binpow(2,(n-1)))+1));
51 |             ll temp=ans;
52 |             for(ll i=1;i<=k-1;i++){
53 |                 ans=mulm(ans,temp);
54 |                 ans%=mod;
55 |                 // ans+=binpow(2,i*(n-1));
56 |             }
57 |             cout<<ans%mod<<endl;
58 |             
59 |         }else{
60 |             ll ans=1;
61 |             
62 |             ans=mulm(ans,((binpow(2,(n-1)))-1));
63 |             ll temp=ans;
64 |             // cout<<ans<<endl;
65 |             for(ll i=1;i<=k-1;i++){
66 |                 ans=mulm(ans,temp);
67 |                 ans%=mod;
68 |                 // ans+=binpow(2,i*(n-1));
69 |             }
70 |             // cout<<ans<<endl;
71 |             ll val1=1;
72 |             for(ll i=1;i<=k;i++){
73 |                 if(i>=2){
74 |                     val1=mulm(val1,binpow(2,(n-1))-1);
75 |                     // cout<<"val1"<<val1<<endl;
76 |                 }
77 |                 ans=summ(ans,mulm(val1,binpow(2,(n)*(k-i))));
78 |                 // cout<<ans<<endl;
79 |                 // cout<<ans<<endl;
80 |                 ans%=mod;
81 |             }
82 |             cout<<ans%mod<<endl;
83 |         }
84 |     }
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/DP/DP-bitmasking/README.MD:
--------------------------------------------------------------------------------
 1 | Problems:
 2 | 
 3 |    https://cses.fi/problemset/task/2181
 4 |    
 5 |    https://cses.fi/problemset/task/1653
 6 |    
 7 |    https://leetcode.com/problems/minimum-cost-to-connect-two-groups-of-points/
 8 |    
 9 |    kick start round A 2022 C problem:
10 |    
11 |    https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb33e/00000000009e762e
12 |    
13 | sources:
14 |    https://www.youtube.com/playlist?list=PLb3g_Z8nEv1icFNrtZqByO1CrWVHLlO5g
15 |    
16 |    https://codeforces.com/blog/entry/47764
17 |    
18 |    
19 |    
20 |    
21 | 


--------------------------------------------------------------------------------
/DP/DP-bitmasking/leetcodemincost2connectpoints.cpp:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public:
 3 |     int dp[13][(1<<12)+5];
 4 |     int mn[13];
 5 |     int ans(vector<vector<int>>& cost,int n,int m,int i,int mask){
 6 |         if(dp[i][mask]!=-1){
 7 |             return dp[i][mask];
 8 |         }
 9 |         int an=INT_MAX;
10 |         if(i==n){
11 |             an=0;
12 |             // cout<<an<<endl;
13 |             for(int j=0;j<m;j++){
14 |                 if(!((1<<j)&mask)){
15 |                     an+=(mn[j]);
16 |                 }
17 |             }
18 |             // cout<<an<<endl;
19 |             return an;
20 |         }
21 |         
22 |         
23 |         
24 |         for(int j=0;j<m;j++){
25 |             an=min(an,cost[i][j]+ans(cost,n,m,i+1,(mask|(1<<j))));
26 |         }
27 |         return dp[i][mask]=an;
28 |         
29 |     }
30 |     
31 |    
32 |     
33 |     
34 |     int connectTwoGroups(vector<vector<int>>& cost) {
35 |         memset(dp,-1,sizeof(dp));
36 |         memset(mn,101,sizeof(mn));
37 |         int mx=INT_MAX;
38 |         int n=cost.size();
39 |         int m=cost[0].size();
40 |         for(int i=0;i<m;i++){
41 |             for(int j=0;j<n;j++){
42 |                 mn[i]=min(mn[i],cost[j][i]);
43 |             }
44 |             // cout<<mn[i]<<" ";
45 |         }
46 |         cout<<endl;
47 |         mx=ans(cost,n,m,0,0);
48 |         return mx;
49 |     }
50 | };
51 | 


--------------------------------------------------------------------------------
/DP/DP-bitmasking/sol1.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll n,m;
16 |  
17 | ll dp[1005][(1<<11)];
18 | // vector<ll> nm;
19 |  
20 | void generate_next_mask(ll currentmask,ll i,ll next_mask,vector<ll> &nm){
21 |     if(i==n){
22 |         nm.push_back(next_mask);
23 |         return ;
24 |     }
25 |  
26 |  
27 |     if(((currentmask>>i)&1)==1){
28 |         generate_next_mask(currentmask,i+1,next_mask,nm);
29 |     }else{
30 |         generate_next_mask(currentmask,i+1,next_mask+(1<<i),nm);
31 |         if(i!=n-1&& ((currentmask>>(i+1))&1)==0){
32 |             generate_next_mask(currentmask,i+2,next_mask,nm);
33 |         }
34 |     }
35 |  
36 | }
37 |  
38 |  
39 | ll ans(ll i,ll mask){
40 |     if(i==m){
41 |         if(mask==0){
42 |             return 1;
43 |         }
44 |         return 0;
45 |     }
46 |  
47 |     if(dp[i][mask]!=-1){
48 |         return dp[i][mask];
49 |     }
50 |     ll an=0;
51 |     // nm.clear();
52 |     vector<ll> nm;
53 |     generate_next_mask(mask,0,0,nm);
54 |     // cout<<nm.size()<<endl;
55 |  
56 |     for(ll j: nm){
57 |         // cout<<j<<"j ";
58 |         an=(an%mod+ans(i+1,j)%mod)%mod;
59 |     }
60 |     return dp[i][mask]=an;
61 |  
62 | }
63 |  
64 |  
65 |  
66 | int main()
67 | {
68 |     ios_base::sync_with_stdio(false); cin.tie(0);
69 |     cin>>n>>m;
70 |     memset(dp,-1,sizeof(dp));
71 |     cout<<ans(0,0)<<endl;
72 |  
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/DP/DP-bitmasking/solkickstart.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | // waiting....
 10 | 
 11 | #include<bits/stdc++.h>
 12 | using namespace std;
 13 | 
 14 | #define ll long long
 15 | 
 16 | ll n;
 17 | string s;
 18 | bool dp[50005][(1<<6)+4];
 19 | 
 20 | vector<bool> checkpalli6(1<<6,false);
 21 | vector<bool> checkpalli5(1<<5,false);
 22 | 
 23 | 
 24 | bool ans(ll i,ll k5,ll k6){
 25 |     if(i>=5 && checkpalli5[k5]){
 26 |         return false;
 27 |     }
 28 |     if(i>=6 && checkpalli6[k6]){
 29 |         return false;
 30 |     }
 31 | 
 32 |     if(i==n){
 33 |         return true;
 34 | 
 35 |     }
 36 |     if(dp[i][k6]){
 37 |         return false;
 38 |     }
 39 | 
 40 |     dp[i][k6]=true;
 41 | 
 42 | 
 43 |     if(s[i]=='0' || s[i]=='?'){
 44 |         ll nk5=(k5<<1)&((1<<5) -1);
 45 | 
 46 |         ll nk6=(k6<<1)&((1<<6) -1);
 47 | 
 48 |         if(ans(i+1,nk5,nk6)){
 49 |             return true;
 50 |         }
 51 |         
 52 |     }
 53 |     
 54 |     if(s[i]=='1' || s[i]=='?'){
 55 |         ll nk5=((k5<<1) +1 )&((1<<5) -1);
 56 | 
 57 |         ll nk6=((k6<<1)+1)&((1<<6) -1);
 58 | 
 59 |         if(ans(i+1,nk5,nk6)){
 60 |             return true;
 61 |         }
 62 |         
 63 |     }
 64 |     return false;
 65 | }
 66 | 
 67 | 
 68 | 
 69 | int main(){
 70 | 
 71 |     for(ll i=0;i<(1<<5);i++){
 72 |         ll c=5;
 73 |         ll temp=i;
 74 |         string s="";
 75 |         while(c--){
 76 |             s+=(temp%2)?"1":"0";
 77 |             temp/=2;
 78 |         }
 79 |         string t=s;
 80 |         reverse(s.begin(),s.end());
 81 |         if(t==s){
 82 |             checkpalli5[i]=true;
 83 |         }
 84 |     }
 85 | 
 86 |     
 87 |     for(ll i=0;i<(1<<6);i++){
 88 |         ll c=6;
 89 |         ll temp=i;
 90 |         string s="";
 91 |         while(c--){
 92 |             s+=(temp%2)?"1":"0";
 93 |             temp/=2;
 94 |         }
 95 |         string t=s;
 96 |         reverse(s.begin(),s.end());
 97 |         if(t==s){
 98 |             checkpalli6[i]=true;
 99 |         }
100 |     }
101 | 
102 |     ll t;
103 |     cin>>t;
104 |     for(ll tt=1;tt<=t;tt++){
105 |         memset(dp,0,sizeof(dp));
106 |         cin>>n;
107 |         cin>>s;
108 |         // cout<<n<<s<<endl;
109 |         cout<<"Case #"<<tt<<": ";
110 | 
111 |         ll check=ans(0,0,0);
112 | 
113 |         if(check){
114 |             cout<<"POSSIBLE"<<endl;
115 |             continue;
116 |         }
117 | 
118 |         cout<<"IMPOSSIBLE"<<endl;
119 | 
120 |         
121 | 
122 | 
123 |         
124 |     }
125 |     return 0;
126 | }
127 | 


--------------------------------------------------------------------------------
/DP/README.MD:
--------------------------------------------------------------------------------
 1 | # problemset:
 2 |   cses dp problem set:
 3 |   https://cses.fi/problemset/task/1633
 4 |   
 5 |   # codeforces problems:- 
 6 |   
 7 |    1. https://codeforces.com/contest/1673/problem/C  
 8 |    2. https://codeforces.com/contest/1660/problem/C
 9 |    3. https://codeforces.com/contest/1000/problem/D 
10 |    4. https://codeforces.com/problemset/problem/1637/D  
11 |    5. https://codeforces.com/problemset/problem/1633/D
12 |    6. https://codeforces.com/problemset/problem/1557/C 
13 |     
14 |     
15 |    # some other problems:
16 |    https://cp-algorithms.com/dynamic_programming/zero_matrix.html
17 |     
18 |  
19 |     
20 |     
21 | 


--------------------------------------------------------------------------------
/DP/cses dp/1093-TwoSetsII.cp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | // ll dp[5005][5005];
15 | #define mod 1000000007
16 |  
17 | ll dp[505][130000];
18 |  
19 |  
20 | int main()
21 | {
22 |     ios_base::sync_with_stdio(false); cin.tie(0);
23 |     ll n;
24 |     cin>>n;
25 |     ll sm=((n)*(n+1))/2;
26 |  
27 |     if(sm%2!=0){
28 |         cout<<"0"<<endl;
29 |         return 0;
30 |     }
31 |     // cout<<"YES"<<endl;
32 |     sm/=2;
33 |     // dp[1][1]=1;
34 |  
35 |     for(ll i=1;i<=n;i++){
36 |         dp[i][0]=1;
37 |     }
38 |     for(ll i=1;i<=n;i++){
39 |         for(ll j=1;j<=sm;j++){
40 |  
41 |             if(j-i>=0){
42 |                 dp[i][j]=(dp[i-1][j]%mod+dp[i-1][j-i]%mod)%mod;
43 |             }else{
44 |                 dp[i][j]=dp[i-1][j]%mod;
45 |             }
46 |         }
47 |     }
48 |  
49 |     cout<<dp[n][sm]<<endl;
50 |  
51 |  
52 |  
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/DP/cses dp/1097-RemovalGames.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | // ll dp[5005][5005];
15 |  
16 |  
17 |  
18 | int main()
19 | {
20 |     ios_base::sync_with_stdio(false); cin.tie(0);
21 |     ll n;
22 |  
23 |     cin>>n;
24 |     ll xrr[n+1];
25 |  
26 |     vector<vector<ll>> dp(n+1,vector<ll>(n+1,0));
27 |  
28 |     ll sm=0;
29 |     for(ll i=1;i<=n;i++){
30 |         cin>>xrr[i];
31 |         sm+=xrr[i];
32 |     }
33 |     // ll ans=-1e9;
34 |     ll ans;
35 |     for(ll i=n;i>=1;i--){
36 |         for(ll j=i;j<=n;j++){
37 |  
38 |                 if(i==j){
39 |                     dp[i][j]=xrr[i];
40 |                     continue;
41 |                 }
42 |                 dp[i][j]=max(xrr[i]-dp[i+1][j],xrr[j]-dp[i][j-1]);
43 |                 
44 |             
45 |         }
46 |     }
47 |     ans=dp[1][n];
48 |     sm+=ans;
49 |     cout<<(sm/2)<<endl;
50 |  
51 |  
52 |  
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/DP/cses dp/1140-Projects.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | // ll dp[5005][5005];
15 | #define mod 1000000007
16 |  
17 | ll dp[505][130000];
18 |  
19 |  
20 | int main()
21 | {
22 |     ios_base::sync_with_stdio(false); cin.tie(0);
23 |     ll n;
24 |     cin>>n;
25 |     vector<pair<pair<ll,ll>,ll>> vec;
26 |     vector<ll> vec1;
27 |     vec1.push_back(0);
28 |     for(ll i=0;i<n;i++){
29 |  
30 |         ll a,b,x;
31 |         cin>>a>>b>>x;
32 |         vec1.push_back(a);
33 |         vec1.push_back(b);
34 |         vec.push_back({{a,b},x});
35 |     }
36 |  
37 |     sort(vec1.begin(),vec1.end());
38 |     vec1.push_back(0);
39 |     vector<ll> v;
40 |     for(ll i=1;i<=(ll)(vec1.size());i++){
41 |         if(vec1[i]!=vec1[i-1]){
42 |             v.push_back(vec1[i-1]);
43 |         }
44 |     }
45 |     ll sz=v.size();
46 |  
47 |     for(ll i=0;i<n;i++){
48 |         ll a=vec[i].first.first;
49 |         ll b=vec[i].first.second;
50 |         // ll c=vec[i].second;
51 |         a=lower_bound(v.begin(),v.end(),a)-v.begin();
52 |         b=lower_bound(v.begin(),v.end(),b)-v.begin();
53 |         vec[i].first.first=b;
54 |         vec[i].first.second=a;
55 |  
56 |     }
57 |  
58 |  
59 |     sort(vec.begin(),vec.end());
60 |  
61 |     vector<ll> vc;
62 |     for(ll i=0;i<n;i++){
63 |         vc.push_back(vec[i].first.first);
64 |     }
65 |  
66 |  
67 |     vector<ll> dp(sz+1,0);
68 |     for(ll i=1;i<=sz;i++){
69 |         ll l=lower_bound(vc.begin(),vc.end(),i)-vc.begin();
70 |         ll r=upper_bound(vc.begin(),vc.end(),i)-vc.begin();
71 |         dp[i]=dp[i-1];
72 |  
73 |         // cout<<l<<" "<<r<<endl;
74 |         for(ll j=l;j<r;j++){
75 |             ll in=vec[j].first.second;
76 |             ll w=vec[j].second;
77 |             dp[i]=max(dp[i],dp[in-1]+w);
78 |         }
79 |     }
80 |  
81 |     cout<<dp[sz]<<endl;
82 |  
83 |     // sort(vec.begin(),vec.end());
84 |  
85 |  
86 |  
87 |  
88 |  
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/DP/cses dp/1145-IncreasingSubsequence.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | int main()
26 | {
27 |     ll n;
28 |     cin>>n;
29 |     ll arr[n];
30 |     // cin>>arr[i];
31 |     for(ll i=0;i<n;i++){
32 |         cin>>arr[i];
33 |     }
34 |     vector<ll> dp(n+1,INT_MAX);
35 |     dp[0]=INT_MIN;
36 |     for(ll i=0;i<n;i++){
37 |         ll j= upper_bound(dp.begin(),dp.end(),arr[i])-dp.begin();
38 |         // j--;
39 |         if(dp[j]>arr[i] && dp[j-1]<arr[i]){
40 |             dp[j]=arr[i];
41 |         }
42 |         
43 |         
44 |     }
45 |     ll ans=0;
46 |     for(ll i=1;i<=n;i++){
47 |         if(dp[i]<INT_MAX){
48 |             ans=i;
49 |         }else{
50 |             break;
51 |         }
52 |     }
53 |  
54 |     cout<<ans<<endl;
55 | }
56 | 


--------------------------------------------------------------------------------
/DP/cses dp/1158-BookShop.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again.....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | #define mod 1000000007
14 |  
15 | ll dp[1005][100005];
16 |  
17 | int main(){
18 |     ios_base::sync_with_stdio(false); cin.tie(0);
19 |     ll n,x;
20 |     cin>>n>>x;
21 |  
22 |     ll hrr[n+1],srr[n+1];
23 |     for(ll i=1;i<=n;i++){
24 |         cin>>hrr[i];
25 |     }
26 |  
27 |     for(ll i=1;i<=n;i++){
28 |         cin>>srr[i];
29 |     }
30 |  
31 |     for(ll i=1;i<=n;i++){
32 |         for(ll j=1;j<=x;j++){
33 |             if(hrr[i]<=j){
34 |                 dp[i][j]=max(dp[i-1][j-hrr[i]]+srr[i],dp[i-1][j]);
35 |             }else{
36 |                 dp[i][j]=dp[i-1][j];
37 |             }
38 |         }
39 |     }
40 |  
41 |  
42 |     cout<<dp[n][x]<<endl;
43 |     // for(ll i=1;i<=n;i++){
44 |     //     for(ll j=1;j<=x;j++){
45 |     //         cout<<dp[i][j]<<" ";
46 |     //     }
47 |     //     cout<<endl;
48 |     // }
49 |  
50 |     
51 |  
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/DP/cses dp/1633-DiceCombinations.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | vector<ll> dp(1000005,0);
26 |  
27 | int main()
28 | {
29 |     ll n;
30 |     cin>>n;
31 |  
32 |     if(n==0){
33 |         cout<<"0"<<endl;
34 |     }
35 |     // dp[1]=1;
36 |     
37 |     for(ll i=1;i<=n;i++){
38 |         ll val=max(i-6,0ll);
39 |         for(ll j=val;j<=i-1;j++){
40 |             dp[i]=add(dp[i],dp[j]);
41 |         }
42 |         // dp[i]=add(dp[i],1);
43 |         if(i<=6){
44 |             dp[i]=add(dp[i],1);
45 |         }
46 |     }
47 |  
48 |     cout<<dp[n]<<endl;
49 |  
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/DP/cses dp/1634-MinimizingCoins.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | vector<ll> dp(1000005,-1);
26 |  
27 | int main()
28 | {
29 |     ll n,x;
30 |     cin>>n>>x;
31 |     // cout<<"YES"<<endl;
32 |     vector<ll> cn;
33 |     // cout<<"YES";
34 |  
35 |     for(ll i=0;i<n;i++){
36 |         ll val;
37 |         cin>>val;
38 |         cn.push_back(val);
39 |         dp[val]=1;
40 |     }
41 |     // cout<<"YES";
42 |     sort(cn.begin(),cn.end());
43 |     for(ll i=1;i<=x;i++){
44 |         if(dp[i]!=-1){
45 |             continue;
46 |         }
47 |         for(ll j=0;j<(ll)cn.size();j++){
48 |             ll val=i-cn[j];
49 |             if(val<0){
50 |                 break;
51 |             }else if(dp[val]==-1){
52 |                 continue;
53 |             }else{
54 |                 if(dp[i]==-1)
55 |                 {
56 |                     dp[i]=dp[val]+1;
57 |                 }else{
58 |                     dp[i]=min(dp[i],dp[val]+1);
59 |                 }
60 |             }
61 |  
62 |  
63 |         }
64 |  
65 |  
66 |     }
67 |  
68 |     cout<<dp[x]<<endl;
69 |     
70 |  
71 |     return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/DP/cses dp/1635-CoinCombinations.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | vector<ll> dp(1000005,0);
26 |  
27 | int main()
28 | {
29 |     ll n,x;
30 |     cin>>n>>x;
31 |     // cout<<"YES"<<endl;
32 |     vector<ll> cn;
33 |     // cout<<"YES";
34 |  
35 |     for(ll i=0;i<n;i++){
36 |         ll val;
37 |         cin>>val;
38 |         cn.push_back(val);
39 |         dp[val]=1;
40 |     }
41 |     // cout<<"YES";
42 |     sort(cn.begin(),cn.end());
43 |     for(ll i=1;i<=x;i++){
44 |         
45 |         for(ll j=0;j<(ll)cn.size();j++){
46 |             ll val=i-cn[j];
47 |             if(val<0){
48 |                 break;
49 |             }else{
50 |                 dp[i]=add(dp[i],dp[val]);
51 |                 
52 |             }
53 |  
54 |  
55 |         }
56 |  
57 |  
58 |     }
59 |  
60 |     cout<<dp[x]<<endl;
61 |     
62 |  
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/DP/cses dp/1636-CoinCombinationII.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 | ll n, x,i,j,val;
25 | ll dp[105][1000005];
26 | vector<ll> cn(105,0);
27 |  
28 |  
29 | int main()
30 | {
31 |     ios_base::sync_with_stdio(false); cin.tie(0);
32 |     cin >> n >> x;
33 |     // cout<<"YES"<<endl;
34 |     // cout<<"YES";
35 |  
36 |     for (i = 1; i <= n; i++)
37 |     {
38 |         
39 |         cin >> val;
40 |         cn[i]=val;
41 |         
42 |  
43 |     }
44 |     dp[0][0]=1;
45 |    
46 |     for (i = 1; i <= n; i++)
47 |     {
48 |         
49 |         for (j = 0; j<=x; j++)
50 |         {
51 |             
52 |             dp[i][j] =dp[i-1][j];
53 |             
54 |             val = j - cn[i];
55 |             if(val>=0)
56 |             {
57 |                 dp[i][j] = add(dp[i][j], dp[i][val]);
58 |             }
59 |         }
60 |         
61 |     }
62 |     
63 |     cout <<dp[n][x]<< endl;
64 |  
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/DP/cses dp/1637-RemoveDigits.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | // vector<vector<ll>> dp(1000005,vector<ll>(101,0));
26 | // ll dp[1000005][101];
27 | // ll dp[1000005]={-1};
28 | int main()
29 | {
30 |     ll n;
31 |     cin>>n;
32 |     vector<ll> dp(n+1,INT_MAX);
33 |     // cout<<dp[2]<<endl;
34 |     dp[n]=0;
35 |  
36 |     for(ll i=n;i>=0;i--){
37 |         if(dp[i]!=INT_MAX){
38 |             ll temp=i;
39 |             while(temp!=0){
40 |                 ll rem=temp%10;
41 |                 // dp[i-rem]=min(dp[i-rem],)
42 |                 if(i-rem>=0){
43 |                     dp[i-rem]=min(dp[i]+1,dp[i-rem]);
44 |                 }
45 |                 temp/=10;
46 |             }
47 |         }
48 |     }
49 |     cout<<dp[0]<<endl;
50 |  
51 |  
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/DP/cses dp/1638-GridPaths.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | #define mod 1000000007
14 |  
15 | ll add(ll x, ll y)
16 | {
17 |     return (x % mod + y % mod) % mod;
18 | }
19 |  
20 | ll mul(ll x, ll y)
21 | {
22 |     return ((x % mod) * (y % mod)) % mod;
23 | }
24 |  
25 | ll dp[1005][1005];
26 | int main()
27 | {
28 |     ll n;
29 |     cin>>n;
30 |     vector<string> vec(n);
31 |     for(ll i=0;i<n;i++){
32 |         cin>>vec[i];
33 |     }
34 |     dp[1][1]=1;
35 |     if(vec[0][0]=='*'){
36 |         cout<<"0"<<endl;
37 |         return 0;
38 |     }
39 |     for(ll i=1;i<=n;i++){
40 |         for(ll j=1;j<=n;j++){
41 |             if(vec[i-1][j-1]=='.'){
42 |                 dp[i][j]=add(dp[i][j],dp[i-1][j]);
43 |                 dp[i][j]=add(dp[i][j],dp[i][j-1]);
44 |             }else{
45 |                 dp[i][j]=0;
46 |             }
47 |         }
48 |     }
49 |  
50 |     cout<<dp[n][n]<<endl;
51 |     
52 |  
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/DP/cses dp/1639-EditDistance.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | #define mod 1000000007
14 | ll n,m;
15 | string s1,s2;
16 | // ll dp[5005][5005];
17 | vector<vector<ll>> dp(5005,vector<ll>(5005,-1));
18 |  
19 | ll rec(ll i,ll j){
20 |     if(i==n || j==m){
21 |         return dp[i][j]=abs(n-i+m-j);
22 |     }
23 |     if(dp[i][j]!=-1){
24 |         return dp[i][j];
25 |     }
26 |  
27 |  
28 |     if(s1[i]==s2[j]){
29 |     ll val4=rec(i+1,j+1);    
30 |     ll val1=1+rec(i,j+1);
31 |     ll val2=1+rec(i+1,j+1);
32 |     ll val3=1+rec(i+1,j);
33 |         return dp[i][j]=min(min(val1,val2),min(val3,val4));    
34 |     }
35 |  
36 |     ll val1=1+rec(i,j+1);
37 |     ll val2=1+rec(i+1,j+1);
38 |     ll val3=1+rec(i+1,j);
39 |     return dp[i][j]=min(val1,min(val3,val2));
40 | }
41 |  
42 |  
43 | int main()
44 | {
45 |     ios_base::sync_with_stdio(false); cin.tie(0);
46 |  
47 |     cin>>s1>>s2;
48 |     n=s1.length(),m=s2.length();   
49 |     ll x=rec(0,0);
50 |     
51 |     cout<<x<<endl;
52 |  
53 |  
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/DP/cses dp/1653-ElevatorRide.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | int main()
16 | {
17 | 
18 |     ios_base::sync_with_stdio(false);
19 | 
20 |     cin.tie(NULL);
21 |     ll n,x;
22 |     cin>>n>>x;
23 |     ll arr[n];
24 |     for(ll i=0;i<n;i++){
25 |         cin>>arr[i];
26 |     }
27 |     ll mx=(1<<n);
28 |     vector<pair<ll,ll>> dp(mx,{0,0});
29 |     dp[0]={1,0};
30 | 
31 | 
32 |     for(ll i=1;i<mx;i++){
33 |         pair<ll,ll> res1={INT_MAX,INT_MAX};
34 |         // cout<<"YES"<<endl;
35 | 
36 |         for(ll j=0;j<n;j++){
37 |             if((i&(1<<j))==0){
38 |                 continue;
39 |             }
40 |             pair<ll,ll> res=dp[(i^(1<<j))];
41 | 
42 |             if(res.second+arr[j]<=x){
43 |                 res.second+=arr[j];
44 | 
45 |             }else{
46 |                 res.first++;
47 |                 res.second=min(res.second,arr[j]);
48 | 
49 |             }
50 |             res1=min(res,res1);
51 | 
52 | 
53 | 
54 |         }
55 |         dp[i]=res1;
56 | 
57 |     }
58 | 
59 |     // cout<<"YS"<<endl;
60 | 
61 |     // for(ll i=1;i<mx;i++){
62 |         // cout<<dp[i].second<<" ";
63 |     // }
64 |     // cout<<endl;
65 | 
66 |     ll ans=dp[(mx-1)].first;
67 |     cout<<ans<<endl;
68 |     
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/DP/cses dp/1744-ReactangularCutting.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 | ll mdl=1000000;
14 | #define mod 1000000007
15 | ll x,y;
16 |  
17 | vector<vector<ll>> dp(505,vector<ll>(505,-1));
18 |  
19 | ll rec(ll a,ll b){
20 |     if(a==b){
21 |         return dp[a][b]=0;
22 |     }
23 |  
24 |     if(dp[a][b]!=-1){
25 |         return dp[a][b];
26 |     }
27 |  
28 |     
29 |     
30 |     
31 |     ll mn=mdl;
32 |  
33 |     for(ll i=1;i<b;i++){
34 |         ll xx1,yy1,xx2,yy2;
35 |         xx1=a;
36 |         yy1=b-i;
37 |         xx2=a;
38 |         yy2=i;
39 |         if(xx1>yy1){
40 |             swap(xx1,yy1);
41 |         }
42 |         if(xx2>yy2){
43 |             swap(xx2,yy2);
44 |         }
45 |         mn=min(mn,1+rec(xx1,yy1)+rec(xx2,yy2));
46 |         
47 |     }
48 |     for(ll i=1;i<a;i++){
49 |         ll xx1,yy1,xx2,yy2;
50 |         xx1=a-i;
51 |         yy1=b;
52 |         xx2=i;
53 |         yy2=b;
54 |         if(xx1>yy1){
55 |             swap(xx1,yy1);
56 |         }
57 |         if(xx2>yy2){
58 |             swap(xx2,yy2);
59 |         }
60 |         mn=min(mn,1+rec(xx1,yy1)+rec(xx2,yy2));
61 |     }
62 |         
63 |     
64 |  
65 |     
66 |     return dp[a][b]=mn;
67 |  
68 | }
69 |  
70 |  
71 | int main()
72 | {
73 |     ios_base::sync_with_stdio(false); cin.tie(0);
74 |  
75 |     cin>>x>>y;
76 |     // n=s1.length(),m=s2.length(); 
77 |     if(x>y){
78 |         swap(x,y);
79 |     }  
80 |     ll an=rec(x,y);
81 |     
82 |     cout<<an<<endl;
83 |  
84 |  
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/DP/cses dp/1745-MoneySum.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 |  
14 | int main()
15 | {
16 |     ios_base::sync_with_stdio(false); cin.tie(0);
17 |  
18 |     ll n;
19 |     cin>>n;
20 |     ll arr[n];
21 |     for(ll i=0;i<n;i++){
22 |         cin>>arr[i];
23 |     }
24 |     sort(arr,arr+n);
25 |     vector<bool> ch(200005,false);
26 |     vector<ll> vec;
27 |  
28 |     vec.push_back(0);
29 |     ll sz=0;
30 |     
31 |     for(ll i=0;i<n;i++){
32 |         // cout<<i<<endl;
33 |         // cout<<sz<<endl;
34 |         ll tm=sz;
35 |         for(ll j=0;j<=tm;j++){
36 |             // cout<<vec[j]<<" ";
37 |             ll in=vec[j]+arr[i];
38 |             if(!ch[in]){
39 |                 ch[in]=true;
40 |                 vec.push_back(in);
41 |                 sz++;
42 |             }
43 |         }
44 |     }
45 |     cout<<sz<<endl;
46 |     sort(vec.begin(),vec.end());
47 |     for(ll i=1;i<=sz;i++){
48 |         cout<<vec[i]<<" ";
49 |     }
50 |  
51 |  
52 |  
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/DP/cses dp/1746-Arraydescription.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 |  
  9 | #include <bits/stdc++.h>
 10 | using namespace std;
 11 |  
 12 | #define ll long long
 13 | #define mod 1000000007
 14 |  
 15 | ll add(ll x, ll y)
 16 | {
 17 |     return (x % mod + y % mod) % mod;
 18 | }
 19 |  
 20 | ll mul(ll x, ll y)
 21 | {
 22 |     return ((x % mod) * (y % mod)) % mod;
 23 | }
 24 |  
 25 | int main()
 26 | {
 27 |     ll n, m;
 28 |     cin >> n >> m;
 29 |     ll arr[n];
 30 |     for (ll i = 0; i < n; i++)
 31 |     {
 32 |         cin >> arr[i];
 33 |     }
 34 |     if (m == 1)
 35 |     {
 36 |         cout << "1" << endl;
 37 |         return 0;
 38 |     }
 39 |     vector<vector<ll>> vec(n + 1, vector<ll>(m + 1, 0));
 40 |  
 41 |     if (arr[0] == 0)
 42 |     {
 43 |         for (ll i = 1; i <= m; i++)
 44 |         {
 45 |             vec[0][i] = 1;
 46 |         }
 47 |     }
 48 |     else
 49 |     {
 50 |         ll x = arr[0];
 51 |         vec[0][x] = 1;
 52 |     }
 53 |  
 54 |     for (ll i = 1; i < n; i++)
 55 |     {
 56 |         if (arr[i] == 0)
 57 |         {
 58 |             for (ll j = 1; j <= m; j++)
 59 |             {
 60 |                 if (j == 1)
 61 |                 {
 62 |                     vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 63 |                     vec[i][j] = add(vec[i - 1][j + 1], vec[i][j]);
 64 |                 }
 65 |                 else if (j == m)
 66 |                 {
 67 |  
 68 |                     vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 69 |                     vec[i][j] = add(vec[i - 1][j - 1], vec[i][j]);
 70 |                 }
 71 |                 else
 72 |                 {
 73 |  
 74 |                     vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 75 |                     vec[i][j] = add(vec[i - 1][j + 1], vec[i][j]);
 76 |                     vec[i][j] = add(vec[i - 1][j - 1], vec[i][j]);
 77 |                 }
 78 |             }
 79 |         }
 80 |         else
 81 |         {
 82 |             ll j = arr[i];
 83 |             if (j == 1)
 84 |             {
 85 |                 vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 86 |                 vec[i][j] = add(vec[i - 1][j + 1], vec[i][j]);
 87 |             }
 88 |             else if (j == m)
 89 |             {
 90 |  
 91 |                 vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 92 |                 vec[i][j] = add(vec[i - 1][j - 1], vec[i][j]);
 93 |             }
 94 |             else
 95 |             {
 96 |  
 97 |                 vec[i][j] = add(vec[i - 1][j], vec[i][j]);
 98 |                 vec[i][j] = add(vec[i - 1][j + 1], vec[i][j]);
 99 |                 vec[i][j] = add(vec[i - 1][j - 1], vec[i][j]);
100 |             }
101 |         }
102 |     }
103 |     ll ans=0;
104 |  
105 |     for(ll i=1;i<=m;i++){
106 |         ans=add(ans,vec[n-1][i]);
107 |     }
108 |     cout<<ans<<endl;
109 | }
110 | 


--------------------------------------------------------------------------------
/DP/cses dp/2181-CountingTilings.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll n,m;
16 |  
17 | ll dp[1005][(1<<11)];
18 | // vector<ll> nm;
19 |  
20 | void generate_next_mask(ll currentmask,ll i,ll next_mask,vector<ll> &nm){
21 |     if(i==n){
22 |         nm.push_back(next_mask);
23 |         return ;
24 |     }
25 |  
26 |  
27 |     if(((currentmask>>i)&1)==1){
28 |         generate_next_mask(currentmask,i+1,next_mask,nm);
29 |     }else{
30 |         generate_next_mask(currentmask,i+1,next_mask+(1<<i),nm);
31 |         if(i!=n-1&& ((currentmask>>(i+1))&1)==0){
32 |             generate_next_mask(currentmask,i+2,next_mask,nm);
33 |         }
34 |     }
35 |  
36 | }
37 |  
38 |  
39 | ll ans(ll i,ll mask){
40 |     if(i==m){
41 |         if(mask==0){
42 |             return 1;
43 |         }
44 |         return 0;
45 |     }
46 |  
47 |     if(dp[i][mask]!=-1){
48 |         return dp[i][mask];
49 |     }
50 |     ll an=0;
51 |     // nm.clear();
52 |     vector<ll> nm;
53 |     generate_next_mask(mask,0,0,nm);
54 |     // cout<<nm.size()<<endl;
55 |  
56 |     for(ll j: nm){
57 |         // cout<<j<<"j ";
58 |         an=(an%mod+ans(i+1,j)%mod)%mod;
59 |     }
60 |     return dp[i][mask]=an;
61 |  
62 | }
63 |  
64 |  
65 |  
66 | int main()
67 | {
68 |     ios_base::sync_with_stdio(false); cin.tie(0);
69 |     cin>>n>>m;
70 |     memset(dp,-1,sizeof(dp));
71 |     cout<<ans(0,0)<<endl;
72 |  
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/DP/cses dp/2220-CountingNumbers.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 |  
16 | ll dp[20][10][2][2];
17 |  
18 |  
19 | ll rec(string a,ll i,ll prev,bool tight,bool check0){
20 |     if(i>=a.length()){
21 |         return 1;
22 |     }
23 |  
24 |     if(prev!=-1 && dp[i][prev][tight][check0]!=-1){
25 |         return dp[i][prev][tight][check0];
26 |     }
27 |     ll val=a[i]-'0';
28 |     ll ans=0;
29 |     // cout<<ans<<endl;
30 |     for(ll j=0;j<=9;j++){
31 |         if(tight && check0 && j<=val){
32 |             ans+=rec(a,i+1,j,j==val,check0 && (j==0));
33 |         }else if(tight && !check0 && j<=val && prev!=j){
34 |             ans+=rec(a,i+1,j,j==val,check0);
35 |         }else if(!tight && check0){
36 |             ans+=rec(a,i+1,j,0,check0 && (j==0));
37 |         }else if(!tight && !check0 && j!=prev){
38 |             ans+=rec(a,i+1,j,0,0);
39 |         }
40 |     }
41 |  
42 |     return dp[i][prev][tight][check0]= ans;
43 |  
44 | }
45 |  
46 | int main()
47 | {
48 |     ios_base::sync_with_stdio(false);
49 |     cin.tie(0);
50 |     ll a,b;
51 |     cin>>a>>b;
52 |     memset(dp,-1,sizeof(dp));
53 |     // cout<<dp[10][9][0][1]<<endl;
54 |     a--;
55 |     string aa=to_string(a);
56 |     string bb=to_string(b);
57 |  
58 |  
59 |     ll ans=rec(bb,0,-1,1,1);
60 |     memset(dp,-1,sizeof(dp));
61 |     
62 |     ans-=rec(aa,0,-1,1,1);
63 |     cout<<ans<<endl;
64 |  
65 |  
66 |  
67 |  
68 |     return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/DP/cses dp/2413-CountingTowers.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again.....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | // ll dp[1005][100005];
16 | ll dp[5][1000005];
17 |  
18 | ll mul(ll x,ll y){
19 |     return ((x%mod)*(y%mod))%mod;
20 | }
21 |  
22 | ll add(ll x,ll y){
23 |     return (x%mod + y%mod)%mod;
24 | }
25 |  
26 | int main(){
27 |     ios_base::sync_with_stdio(false); cin.tie(0);
28 |     dp[0][1]=1;
29 |     dp[1][1]=1;
30 |     dp[2][1]=1;
31 |     dp[3][1]=1;
32 |     dp[4][1]=2;
33 |     for(ll i=2;i<=1000002;i++){
34 |         dp[4][i]=mul(2,dp[4][i-1]);
35 |         ll val=mul(3,dp[0][i-1]);
36 |         val=add(val,dp[1][i-1]);
37 |         dp[4][i]=add(dp[4][i],val);
38 |  
39 |         dp[0][i]=add(dp[4][i-1],mul(3,dp[0][i-1]));
40 |         dp[1][i]=add(dp[4][i-1] , dp[1][i-1]);
41 |         dp[2][i]=add(dp[4][i-1] , dp[0][i-1]);
42 |         dp[3][i]=add(dp[4][i-1] , dp[0][i-1]);
43 |  
44 |     }
45 |     ll t;
46 |     cin>>t;
47 |  
48 |     while(t--){
49 |         ll n;
50 |         cin>>n;
51 |         cout<<dp[4][n]<<endl;
52 |     }
53 |  
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/DP/digit-dp/README.MD:
--------------------------------------------------------------------------------
 1 | problems:-
 2 | 
 3 |   https://cses.fi/problemset/task/2220 
 4 |   
 5 |   https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb33e/00000000009e73ea
 6 |   
 7 | video source:-
 8 | 
 9 |   https://www.youtube.com/playlist?list=PLb3g_Z8nEv1hB69JL9K7KfEyK8iQNj9nX
10 |   
11 |   
12 | 


--------------------------------------------------------------------------------
/DP/digit-dp/kickstartroundA22problemD.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | string a,b;
14 | 
15 | ll dp[110][110][13][2][2][2];
16 | 
17 | ll rec(string x,string y,ll sm1,ll mul,ll sum,ll i,ll tight,ll uptight,ll prevzeros){
18 |     if(sum>sm1 || (sm1-sum)>(y.length()-i)*9){
19 |         return 0;
20 |     }
21 |     if(i==x.length()){
22 |         
23 |         if(mul==0 && sum==sm1){
24 |             // cout<<sum<<endl;
25 |             return 1;
26 |         }
27 |         return 0;
28 |     }
29 |     if(dp[mul][sum][i][tight][uptight][prevzeros]!=-1){
30 |         return dp[mul][sum][i][tight][uptight][prevzeros];
31 |     }
32 |     
33 |     
34 |     ll lb=(tight==1)?(x[i]-'0'):0;
35 |     ll ub=(uptight==1)?(y[i]-'0'):9;
36 |     ll an=0;
37 | 
38 |     for(int j=lb;j<=ub;j++){
39 |         ll pv=prevzeros;
40 |         if(prevzeros==1 && j==0){
41 |             an+=(rec(x,y,sm1,mul,sum+j,i+1,tight,0,prevzeros));
42 | 
43 |             continue;
44 |         }else if(prevzeros==1){
45 |             pv=0;
46 |         }
47 |         ll mulp=(mul*j)%sm1;
48 |         ll tight1=((tight==1)&&(j==lb))?1:0;
49 |         ll uptight1=((uptight==1)&&(j==ub))?1:0;
50 |         an+=(rec(x,y,sm1,mulp,sum+j,i+1,tight1,uptight1,pv));
51 |     }
52 |     return dp[mul][sum][i][tight][uptight][prevzeros]=an;
53 | }
54 | 
55 | int main()
56 | {
57 |     ios_base::sync_with_stdio(false);
58 |     cin.tie(NULL);
59 |     ll t;
60 |     cin>>t;
61 |     for(ll tt=1;tt<=t;tt++){
62 |         cin>>a>>b;
63 | 
64 |         string temp="";
65 |         ll val=b.length()-a.length();
66 |         while(val--){
67 |             temp+="0";
68 |         }
69 |         temp+=a;
70 |         // cout<<temp<<endl;
71 | 
72 |         ll ans=0;
73 |         for(ll sm1=1;sm1<=109;sm1++){
74 |             memset(dp,-1,sizeof(dp));
75 |             ans+=rec(temp,b,sm1,1,0,0,1,1,1);
76 |         }
77 |         cout<<"Case #"<<tt<<": ";
78 |         cout<<ans<<endl;
79 | 
80 | 
81 |     }
82 | 
83 |     return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/DP/digit-dp/soln1usingP&C.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | // waiting....
10 |  
11 | #include<bits/stdc++.h>
12 | using namespace std;
13 |  
14 | #define ll long long
15 |  
16 |  
17 |  
18 | ll fac[19];
19 |  
20 | ll val_bound(string s,ll i){
21 |     if(i==s.length()){
22 |         return 0;
23 |     }
24 |     ll val=s[i]-'0';
25 |     if(i==0){
26 |         return (((val-1)*fac[s.length()-i-1]) + val_bound(s,i+1));
27 |     }
28 |  
29 |     ll prev=s[i-1]-'0';
30 |     if(prev<val){
31 |         return (((val-1)*fac[s.length()-i-1]) + val_bound(s,i+1));
32 |     }
33 |     if(prev==val){
34 |         return ((val)*fac[s.length()-i-1]);
35 |     }
36 |  
37 |  
38 |     return (((val)*fac[s.length()-i-1]) + val_bound(s,i+1));
39 | }
40 |  
41 |  
42 | int main(){
43 |     fac[0]=1;
44 |     for(ll i=1;i<=18;i++){
45 |         fac[i]=(fac[i-1]*9);
46 |     }
47 |  
48 |  
49 |  
50 |     string a,b;
51 |     cin>>a>>b;
52 |  
53 |     ll n=a.length(),m=b.length();
54 |  
55 |  
56 |     bool checkb=false;
57 |     for(ll i=1;i<m;i++){
58 |         if(b[i]==b[i-1]){
59 |             checkb=true;
60 |             break;
61 |         }
62 |     }
63 |     ll val1=val_bound(a,0);
64 |     ll val2=val_bound(b,0);
65 |     if(!checkb){
66 |         val2++;
67 |     }
68 |  
69 |     
70 |  
71 |     if(n==m){
72 |  
73 |         
74 |  
75 |         ll ans=(val2-val1);
76 |         cout<<ans<<endl;
77 |         return 0;
78 |         
79 |     }
80 |     ll ans=0;
81 |  
82 |     for(ll i=n;i<m;i++){
83 |         ans=(ans+fac[i]);
84 |     }
85 |     ans=(ans-val1);
86 |  
87 |     ans=(ans+val2);
88 |     cout<<ans<<endl;
89 |  
90 |  
91 |  
92 |     
93 |  
94 |  
95 |     return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/DP/digit-dp/soln1usingdigitdp.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 |  
16 | ll dp[20][10][2][2];
17 |  
18 |  
19 | ll rec(string a,ll i,ll prev,bool tight,bool check0){
20 |     if(i>=a.length()){
21 |         return 1;
22 |     }
23 |  
24 |     if(prev!=-1 && dp[i][prev][tight][check0]!=-1){
25 |         return dp[i][prev][tight][check0];
26 |     }
27 |     ll val=a[i]-'0';
28 |     ll ans=0;
29 |     // cout<<ans<<endl;
30 |     for(ll j=0;j<=9;j++){
31 |         if(tight && check0 && j<=val){
32 |             ans+=rec(a,i+1,j,j==val,check0 && (j==0));
33 |         }else if(tight && !check0 && j<=val && prev!=j){
34 |             ans+=rec(a,i+1,j,j==val,check0);
35 |         }else if(!tight && check0){
36 |             ans+=rec(a,i+1,j,0,check0 && (j==0));
37 |         }else if(!tight && !check0 && j!=prev){
38 |             ans+=rec(a,i+1,j,0,0);
39 |         }
40 |     }
41 |  
42 |     return dp[i][prev][tight][check0]= ans;
43 |  
44 | }
45 |  
46 | int main()
47 | {
48 |     ios_base::sync_with_stdio(false);
49 |     cin.tie(0);
50 |     ll a,b;
51 |     cin>>a>>b;
52 |     memset(dp,-1,sizeof(dp));
53 |     // cout<<dp[10][9][0][1]<<endl;
54 |     a--;
55 |     string aa=to_string(a);
56 |     string bb=to_string(b);
57 |  
58 |  
59 |     ll ans=rec(bb,0,-1,1,1);
60 |     memset(dp,-1,sizeof(dp));
61 |     
62 |     ans-=rec(aa,0,-1,1,1);
63 |     cout<<ans<<endl;
64 |  
65 |  
66 |  
67 |  
68 |     return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/Google Online Coding Challenge 2022/problem1.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |   problem :
  3 |   given a n node tree with some value assign to each node you have to print no of paths starting from node 1 such that max frequency of value of that paths' node is >= half of the lenght of that path.
  4 |   
  5 |   constraint:
  6 |   1<=n<=10^5
  7 |   1<=val<=10^5
  8 |   
  9 |   
 10 |   test case:
 11 |   
 12 |     6
 13 |     1 6
 14 |     1 4
 15 |     4 3
 16 |     4 5
 17 |     4 2
 18 |     1 2 1 3 1 1
 19 |     
 20 |     
 21 |     now we know lest write all the paths 
 22 |     path1 1-2--> 1-4-2 (value wise 1 3 2 ) we can see frequency of 1 which is 1  is  equal to len/2(down) means 3/2=1;    --> true
 23 |     path2 1-3--> 1-4-3 (value wise 1 3 1 ) we can see frequency of 1 which is 2  is greater then len/2(down) means 3/2=1; --> true
 24 |     path3 1-4--> 1-4 (value wise 1 1 ) we can see frequency of 1 which is 2  is greater then len/2(down) means 2/2=1;     --> true
 25 |     path4 1-5--> 1-4-5 (value wise 1 3 1 ) we can see frequency of 1 which is 2  is greater then len/2(down) means 3/2=1; --> true
 26 |     path5 1-6--> 1-6 (value wise 1 1 ) we can see frequency of 1 which is 2  is greater then len/2(down) means 2/2=1;     --> true
 27 |     
 28 |     now we can clearly see all the paths satisfy the condition so answer will be 5;
 29 |     
 30 |     
 31 |     approach:-
 32 |     brute force:
 33 |      we can write simple dfs and maintain a cnt array which will store freq of nodes val;
 34 |      and manullay by iterating from 1 to n we can find max value of frequency so time comp will be O(n^2);
 35 |  
 36 |  
 37 |     optimal approach:
 38 |       now focus on count array how can we compute max in less time?
 39 |       segment trees?
 40 |       if we maintain a segment tree and then seg[0] will be max of that freq array so this query time comp--> O(1)
 41 |       and remember we need to update value  which will be in O(logn);
 42 |       so time comp--> O(nlogn);
 43 | 
 44 | */
 45 | 
 46 | 
 47 | 
 48 | // JAI BAJARANG BALI
 49 | 
 50 | // manitianajay45
 51 | 
 52 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 53 | 
 54 | // sab moh maya hai....
 55 | 
 56 | #include <bits/stdc++.h>
 57 | using namespace std;
 58 | 
 59 | #define ll long long
 60 | #define mod 1000000007
 61 | 
 62 | ll n;
 63 | 
 64 | 
 65 | vector<ll> cnt(800005,0);
 66 | vector<ll> visited(100005,false);
 67 | vector<ll> crr(100005,0);
 68 | vector<ll> graph[100005];
 69 | 
 70 | 
 71 | void update(ll i,ll val,ll x,ll l,ll r){
 72 |     if(r-l==1){
 73 |         cnt[x]=val;
 74 |         return ;
 75 |     }
 76 | 
 77 |     ll mid=(l+r)/2;
 78 |     if(i<mid){
 79 |         update(i,val,2*x+1,l,mid);
 80 |     }else{
 81 |         update(i,val,2*x+2,mid,r);
 82 | 
 83 |     }
 84 |     cnt[x]=max(cnt[2*x+1],cnt[2*x+2]);
 85 | }
 86 | 
 87 | ll sz=1;
 88 | 
 89 | 
 90 | ll ans=0;
 91 | ll tl=1;
 92 | 
 93 | void dfs(ll v){
 94 | 
 95 |     visited[v]=true;
 96 |     for(auto i:graph[v]){
 97 |         if(!visited[i]){
 98 |             cnt[crr[i]]++;
 99 |             update(crr[i],cnt[crr[i]]+1,0,0,sz);
100 |             tl++;
101 |             ll mx=cnt[0];
102 | 
103 |             if(mx>=(tl)/2){
104 |                 ans++;
105 |             }
106 |             dfs(i);
107 |             tl--;
108 |             update(crr[i],cnt[crr[i]]-1,0,0,sz);
109 | 
110 |         }
111 |     }
112 | 
113 | 
114 | }
115 | 
116 | int main(){
117 |     cin>>n;
118 |     
119 | 
120 |     for(ll i=0;i<n-1;i++){
121 |         ll u,v;
122 |         cin>>u>>v;
123 |         graph[u].push_back(v);
124 |         graph[v].push_back(u);
125 |     }
126 | 
127 |     for(ll i=1;i<=n;i++){
128 |         cin>>crr[i];
129 |     }
130 | 
131 |     while(sz<n){
132 |         sz*=2;
133 |     }
134 |     update(crr[1],1,0,0,sz);
135 | 
136 |     dfs(1);
137 |     cout<<ans<<endl;
138 | 
139 |     return 0;
140 | 
141 | 
142 | }
143 | 
144 | 


--------------------------------------------------------------------------------
/Interactive problems/1.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunsushine, give me some rain,give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | // waiting....
10 | 
11 | /*
12 |   basically personally problem looks difficult to approach but after having look at constraint which are
13 | queries<=31 and (a and b <= 2 x 10^9 ) by which i started thinking about bits.
14 | so hint : bits. 
15 | */
16 |  
17 | #include <bits/stdc++.h>
18 | using namespace std;
19 |  
20 | #define ll long long
21 |  
22 |  
23 |  
24 | ll ask(ll a,ll b){
25 |     cout<<"? "<<a<<" "<<b<<endl;
26 |     ll val;
27 |     cin>>val;
28 |     return val;
29 | }
30 |  
31 | int main()
32 | {
33 |     ll t;
34 |     cin >> t;
35 |     while (t--)
36 |     {
37 |         // ll val;
38 |         // val=ask(1,3);
39 |         vector<ll> bits;
40 |         ll ans=0;
41 |         ll cnt=0;
42 |         
43 |  
44 |  
45 |         for(ll i=0;i<30;i++){
46 |             ll a=(1<<cnt) - ans;
47 |             // cnt++;
48 |             ll b=a + (1<<(cnt+1));
49 |             ll val=ask(a,b);
50 |             ll vll=(1<<(cnt));
51 |  
52 |             val/=vll;
53 |             if(val%2==0){
54 |                 ans+=(1<<cnt);
55 |             }
56 |             cnt++;
57 |         }
58 |  
59 |         cout<<"! "<<ans<<endl;
60 |  
61 |  
62 |  
63 |     }
64 |     return 0;
65 | }
66 | 
67 | 


--------------------------------------------------------------------------------
/Interactive problems/10.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sun shine, give me some rain, give me some little more chance to grow up once again 
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 |  
 9 | #define ll long long
10 | #define mod 1000000007
11 |  
12 |  
13 | ll ask(ll l, ll r)
14 | {
15 |     if (l >= r) 
16 |     {
17 |         return -1;
18 |     }
19 |     cout<<"? "<<l+1<<" "<<r+1<<endl;
20 |     ll val;
21 |     cin>>val;
22 |     return val-1;
23 | }
24 |  
25 | int main()
26 | {
27 |     ll n;
28 |     cin>>n;
29 |     ll smax;
30 |     smax=ask(0,n-1);
31 |     ll l,r;
32 |     if(smax==0 || ask(0,smax)!=smax)
33 |     {
34 |         l=smax;
35 |         r=n-1;
36 |         ll m;
37 |         
38 |         while(r-l>1)
39 |         {
40 |             m=(l+r)/2;
41 |             if(ask(smax,m)==smax)
42 |             {
43 |                 r=m;
44 |             }else
45 |             {
46 |                 l=m;
47 |             }
48 |         }
49 |         cout<<"! "<<r+1<<endl;
50 |     }else
51 |     {
52 |         l=0;
53 |         r=smax;
54 |         ll m;
55 |         
56 |         while(r-l>1)
57 |         {
58 |             m=(l+r)/2;
59 |             if(ask(m,smax)==smax)
60 |             {
61 |                 l=m;
62 |             }else
63 |             {
64 |                 r=m;
65 |             }
66 |         }
67 |         cout<<"! "<<l+1<<endl;
68 |  
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/Interactive problems/11.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | 
 11 | 
 12 |     In this problem value means total length of functional railway line.
 13 | max value means using all functional line we can traverse through all railway station and value should be maximum (basically spanning tree with max value);
 14 | and min value vice versa
 15 | 
 16 | for example
 17 | 
 18 |         1---(1)-----2---(4)---4---(5)---5 
 19 |          \              /
 20 |            (2)     (3)
 21 |              \      /
 22 |                3
 23 | 
 24 | now max value= 2+ 3 +4+5;(in case of all functional railway lines (11111));
 25 | min value= 1+2 +4 +5    (in case of all functional railway lines (11111));
 26 | 
 27 | now approach is 
 28 | 
 29 | firstly we will find out all edges in m queries in each query we will fix a single railway line functional and other line will be not functional (10000,01000,00100,00010,00001);
 30 | now we have value of every edge
 31 | 
 32 | now we will sort it and put active intial j values for all 1<=J<=m;
 33 | and can find out which railway line must active and which don't need to be;
 34 | bcs order is sorted so the maximum will not included if a cycle created.
 35 | 
 36 | 
 37 | 
 38 | 
 39 | */
 40 | 
 41 | #include <bits/stdc++.h>
 42 | using namespace std;
 43 | 
 44 | #define ll long long
 45 | 
 46 | ll ask(string s){
 47 |     cout<<"? "<<s<<endl;
 48 | 
 49 |     ll val;
 50 |     cin>>val;
 51 |     return val;
 52 | }
 53 | 
 54 | int main()
 55 | {
 56 |     ios_base::sync_with_stdio(false);
 57 |     cin.tie(NULL);
 58 |     ll n,m;
 59 |     cin>>n>>m;
 60 | 
 61 | 
 62 |     string s="";
 63 |     for(ll i=0;i<m;i++){
 64 |         s+="0";
 65 |     }
 66 | 
 67 |     ll mx=INT_MAX;
 68 | 
 69 |     vector<pair<ll,ll>> edges;
 70 | 
 71 |     for(ll i=0;i<m;i++){
 72 |         s[i]='1';
 73 |         ll val=ask(s);
 74 |         edges.push_back({val,i});
 75 |         
 76 |         s[i]='0';
 77 |     }
 78 | 
 79 | 
 80 | 
 81 |     sort(edges.begin(),edges.end());
 82 | 
 83 |     ll ans=0;
 84 |     
 85 |     for(ll i=0;i<(ll)edges.size();i++){
 86 |         s[edges[i].second]='1';
 87 |         ll vl=ask(s);
 88 | 
 89 |         if(vl-ans==edges[i].first){
 90 |             ans+=edges[i].first;
 91 |         }else{
 92 |             s[edges[i].second]='0';
 93 | 
 94 |         }
 95 | 
 96 | 
 97 | 
 98 |     }
 99 | 
100 |     cout<<"! "<<ans<<endl;
101 |     return 0;
102 | }
103 | 


--------------------------------------------------------------------------------
/Interactive problems/12.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | 
 10 | 
 11 | /*
 12 | bascially the problem is about find out a string which length is <=1000 
 13 | we can perform 2 kind of queries
 14 | 
 15 | query1(i)--> which returns us the ith char of string,       no of queries we can ask <=26;
 16 | query2(l,r)--> which returns us no of distinct char between index [l,r],    no of queries we can ask<=6000;
 17 | 
 18 | 
 19 | case - I (char is occuring first time in string):-
 20 | now by looking at maximum no of queries we can assure that query one will ask for finding distinct element which does not occurs in the string before that index,
 21 | for ex- guess
 22 | now let's consider we have find out "gu" now we are on index 3 now we know that particular char does not exist before so we can use (query1);
 23 | but now que is how can we know that particular char exist or not before?
 24 | it's simple we can run query2(1,i+1) and maintain a variable which cnt distinct char, now if previous index 
 25 | 
 26 | cnt +1 == query2(l,i+1)
 27 | then we can say char is distinct and we can return;
 28 | 
 29 | Case-II: (char is occured before in string);
 30 | let's consider wrost case scenario, if all the 26 char exist before ith index in string then?
 31 | brute force:- we can just store every char 's last pos in array and sort it pos wise; and can iterate over array from first index , and when it gives no of distinct 
 32 | char is equal to no of (sz-j)+1 means that element is distinct and we can break at that index now can simply write the ans char as (j-1)th char;
 33 | but max no of queries will be more then 25000;
 34 | how to optimise?
 35 | just look at max no of queries constraint we can think about binary search?
 36 | can we? yes.
 37 | 
 38 | 
 39 | bcs pos array is sorted we can simply use binary search for finding first index on which that current char is distinct;
 40 | 
 41 | for binary search implementation you can look at code;
 42 | 
 43 | 
 44 | 
 45 | 
 46 | 
 47 | */
 48 | 
 49 | #include<bits/stdc++.h>
 50 | using namespace std;
 51 | 
 52 | #define ll long long
 53 | 
 54 | 
 55 | 
 56 | char query1(ll i){
 57 |     cout<<"? 1 "<<i<<endl;
 58 |     char ch;
 59 |     cin>>ch;
 60 |     return ch;
 61 | }
 62 | 
 63 | 
 64 | 
 65 | ll query2(ll l,ll r){
 66 |     cout<<"? 2 "<<l<<" "<<r<<endl;
 67 |     ll ch;
 68 |     cin>>ch;
 69 |     return ch;
 70 | }
 71 | 
 72 | int main(){
 73 |     ios_base::sync_with_stdio(false);
 74 |     cin.tie(NULL);
 75 |     
 76 |         ll n;
 77 |         cin>>n;
 78 | 
 79 |         string s="";
 80 |         vector<ll> pos(26,0);
 81 |         char ch=query1(1);
 82 |         s+=ch;
 83 | 
 84 |         ll val=(s[0]-'a');
 85 |         pos[val]=1;
 86 |         vector<pair<ll,ll>> pr;
 87 | 
 88 |         for(ll i=1;i<n;i++){
 89 |             pr.clear();
 90 |             for(ll j=0;j<26;j++){
 91 |                 if(pos[j]!=0){
 92 |                     pr.push_back({pos[j],j});
 93 |                 }
 94 |             }
 95 | 
 96 | 
 97 |             ll sz=pr.size();
 98 |             sort(pr.begin(),pr.end());
 99 |             ll val=query2(1,i+1);
100 | 
101 |             if(val==sz+1){
102 |                 char cc=query1(i+1);
103 |                 s+=cc;
104 |                 ll v=s[i]-'a';
105 |                 pos[v]=i+1;
106 |                 continue;
107 |             }
108 | 
109 | 
110 |             ll l=0,r=sz-1;
111 |             ll ans=0;
112 |             while(r>=l){
113 |                 ll mid=(l+r)/2; 
114 |                 ll vll=query2(pr[mid].first,i+1);
115 | 
116 |                 if(vll==(sz-mid+1)){
117 |                     r=mid-1;
118 |                 }else{
119 |                     ans=mid;
120 |                     l=mid+1;
121 |                 }
122 |             }
123 |             s+=('a'+pr[ans].second);
124 |             
125 |             ll v=s[i]-'a';
126 |             pos[v]=i+1;
127 | 
128 |             
129 | 
130 |         }
131 |         cout<<"! "<<s<<endl;
132 | 
133 | 
134 |     
135 |     return 0;
136 | 
137 | }
138 | 


--------------------------------------------------------------------------------
/Interactive problems/2.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again
  6 |  
  7 | // sab moh maya hai....
  8 |  
  9 | // waiting....
 10 |  
 11 | #include <bits/stdc++.h>
 12 | using namespace std;
 13 |  
 14 | #define ll long long
 15 |  
 16 | // 1 2 0 3 4
 17 |  
 18 | ll ask(ll i, ll j, ll k)
 19 | {
 20 |     cout << "? " << i << " " << j << " " << k << endl;
 21 |     ll val;
 22 |     cin >> val;
 23 |     
 24 |     return val;
 25 | }
 26 |  
 27 | int main()
 28 | {
 29 |     ll t;
 30 |     cin >> t;
 31 |     while(t--){
 32 |     ll n;
 33 |     cin >> n;
 34 |     ll j = 0;
 35 |     vector<ll> ss;
 36 |  
 37 |     for (ll i = 1; i <= n; i++)
 38 |     {
 39 |         ss.push_back(i);
 40 |     }
 41 |  
 42 |     while ((ll)ss.size() > 2)
 43 |     {
 44 |         vector<ll> s1;
 45 |         vector<bool> visited(n+1,false);
 46 |         for (ll i = 0; i+4 <= (ll)ss.size(); i+=4)
 47 |         {
 48 |             ll a = ss[i];
 49 |             ll b = ss[i + 1];
 50 |             ll c = ss[i + 2];
 51 |             ll d = ss[i + 3];
 52 |  
 53 |             ll val[4];
 54 |             val[0] = ask(a, b, c);
 55 |             val[1] = ask(a, b, d);
 56 |             val[2] = ask(a, c, d);
 57 |             val[3] = ask(b, c, d);
 58 |  
 59 |             ll mn = 0;
 60 |             for (ll k = 0; k < 4; k++)
 61 |             {
 62 |                 mn = max(mn, val[k]);
 63 |             }
 64 |             ll ans1, ans2;
 65 |             if(val[0]==mn && val[1]==mn){
 66 |                 ans1=a;
 67 |                 ans2=b;
 68 |             }else if(val[0]==mn && val[2]==mn){
 69 |                 ans1=a;
 70 |                 ans2=c;
 71 |             }else if(val[0]==mn && val[3]==mn){
 72 |                 ans1=b;
 73 |                 ans2=c;
 74 |             }else if(val[1]==mn && val[2]==mn){
 75 |                 ans1=a;
 76 |                 ans2=d;
 77 |             }else if(val[1]==mn && val[3]==mn){
 78 |                 ans1=b;
 79 |                 ans2=d;
 80 |             }else if(val[2]==mn && val[3]==mn){
 81 |                 ans1=c;
 82 |                 ans2=d;
 83 |             }
 84 |             if(!visited[ans1]){
 85 |                 visited[ans1]=true;
 86 |                 s1.push_back(ans1);
 87 |             }
 88 |             
 89 |             if(!visited[ans2]){
 90 |                 visited[ans2]=true;
 91 |                 s1.push_back(ans2);
 92 |             }
 93 |             
 94 |         }
 95 |  
 96 |         ll len=ss.size();
 97 |         if(len%4!=0 && len>=4){
 98 |             for(ll j=len-1;j>=len-len%4;j--){
 99 |                 s1.push_back(ss[j]);
100 |             }
101 |         }
102 |         
103 |         if(s1.size()==3){
104 |             for(ll k=1;k<=n;k++){
105 |                 if(s1[0]!=k && s1[1]!=k && s1[2]!=k){
106 |                     s1.push_back(k);
107 |                     break;
108 |                 }
109 |             }
110 |         }else if(s1.size()==1){
111 |             for(ll k=1;k<=n;k++){
112 |                 if(s1[0]!=k){
113 |                     s1.push_back(k);
114 |                     break;
115 |                 }
116 |             }
117 |         }
118 |         ss=s1;
119 |     
120 |  
121 |  
122 |         
123 |     }
124 |     
125 |  
126 |     cout<<"! ";
127 |     for(auto i:ss){
128 |         cout<<i<<" ";
129 |     }
130 |     
131 |     cout<<endl;
132 |     }
133 |  
134 |     return 0;
135 | }
136 | 


--------------------------------------------------------------------------------
/Interactive problems/3.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | // waiting....
10 |  
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 |  
14 | #define ll long long
15 |  
16 | ll ask(ll i)
17 | {
18 |  
19 |     cout << "? " << i << endl;
20 |     ll val;
21 |     cin >> val;
22 |     return val;
23 | }
24 |  
25 | int main()
26 | {
27 |     ll t;
28 |     cin >> t;
29 |     while (t--)
30 |     {
31 |         ll n;
32 |         cin >> n;
33 |         ll prr[n + 1];
34 |         bool fl = false;
35 |         vector<bool> flag(n + 1, false);
36 |         ll cnt = 0;
37 |  
38 |         // ask(1);
39 |         // ll i = 1;
40 |         for (ll i = 1; i <= n; i++)
41 |         {
42 |             if (!flag[i])
43 |             {
44 |                 ll in=ask(i);
45 |                 ll val=ask(i);
46 |                 if(in==val){
47 |                     prr[in]=val;
48 |                     continue;
49 |                 }
50 |                 while(!flag[val]){
51 |                     prr[in]=val;
52 |                     flag[val]=true;
53 |                     in=val;
54 |                     val=ask(i);
55 |                 }
56 |             }
57 |         }
58 |         cout << "! ";
59 |         for (ll i = 1; i <= n; i++)
60 |         {
61 |             cout << prr[i] << " ";
62 |         }
63 |         cout << endl;
64 |     }
65 |  
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/Interactive problems/4.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | // waiting....
10 |  
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 |  
14 | #define ll long long
15 |  
16 | ll ask(ll a, ll b, ll c)
17 | {
18 |  
19 |     cout << "? " << a << " " << b << " " << c << endl;
20 |     ll val;
21 |     cin >> val;
22 |     return val;
23 | }
24 |  
25 | int main()
26 | {
27 |     ll t;
28 |     cin >> t;
29 |     while (t--)
30 |     {
31 |         ll N;
32 |         cin >> N;
33 |         ll val = ask(1, 2, 3);
34 |         ll x, y;
35 |         for (ll i = 2; i <= N-2; i++)
36 |         {
37 |             ll xh = ask(i, (i + 1), (i + 2));
38 |             if (xh != val)
39 |             {
40 |                 x=i;
41 |                 y=i+1;
42 |                 break;
43 |             }
44 |         }
45 |  
46 |  
47 |         ll n = x;
48 |         ll m=y;
49 |         ll imp[N+1];
50 |         ll fn1, fn2;
51 |         for (ll i = 1; i <= N; i++)
52 |         {
53 |             if (n != i && m != i)
54 |             {
55 |                 ll fn = ask(n, m, i);
56 |                 if (fn == 1)
57 |                 {
58 |                     fn1 = i;
59 |                 }
60 |                 else
61 |                 {
62 |                     fn2 = i;
63 |                 }
64 |                 imp[i] = fn;
65 |             }
66 |         }
67 |         val = ask(n, fn1, fn2);
68 |         imp[n] = val;
69 |         val = ask(m, fn1, fn2);
70 |         imp[m] = val;
71 |         ll ans = 0;
72 |  
73 |         // cout<<n<<" "<<m<<endl;
74 |         vector<ll> v;
75 |         for (ll i = 1; i <= N; i++)
76 |         {
77 |             if (imp[i] == 0)
78 |             {
79 |                 // cout<<i<<" ";
80 |                 v.push_back(i);
81 |                 ans++;
82 |             }
83 |         }
84 |         cout << "! " << ans << " ";
85 |         for(auto i:v){
86 |             cout<<i<<" ";
87 |         }
88 |         cout << endl;
89 |     }
90 |  
91 |     return 0;
92 | }
93 |  
94 | // 0 1 1 0 1 0
95 | 


--------------------------------------------------------------------------------
/Interactive problems/7.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 |  
15 | ll askand(ll a, ll b){
16 |     cout<<"and "<<a<<" "<<b<<endl;
17 |     ll val;
18 |     cin>>val;
19 |     return val;
20 | }
21 |  
22 | ll askor(ll a,ll b){
23 |     cout<<"or "<<a<<" "<<b<<endl;
24 |     ll val;
25 |     cin>>val;
26 |     return val;
27 | }
28 |  
29 |  
30 | int main(){
31 |     ll n,k;
32 |     cin>>n>>k;
33 |     vector<ll> v;
34 |     ll a12,a23,a13;
35 |     a12=askand(1,2) + askor(1,2);
36 |     a23=askand(2,3) + askor(2,3);
37 |     a13=askand(1,3) + askor(1,3);
38 |  
39 |     ll a1,a2,a3;
40 |     a1=(a12-a23+a13)/2;
41 |     a3=a13-a1;
42 |     a2=a12-a1;
43 |     v.push_back(a1);
44 |     v.push_back(a2);
45 |     v.push_back(a3);
46 |  
47 |     for(ll i=4;i<=n;i++){
48 |         ll vl=askand(1,i) + askor(1,i);
49 |         v.push_back(vl-a1);
50 |     }
51 |     sort(v.begin(),v.end());
52 |  
53 |     cout<<"finish "<<v[k-1]<<endl;
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Interactive problems/8.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // sab moh maya hai...
  6 |  
  7 | // give me some sunshine, give me some rain. give me another chance to grow up once again
  8 |  
  9 | #include<bits/stdc++.h>
 10 | using namespace std;
 11 |  
 12 | #define ll long long
 13 | ll n;
 14 | vector<pair<ll,ll>> ans;
 15 | vector<ll> ask(ll r)
 16 | {
 17 |     cout<<"? "<<r+1<<endl;
 18 |     cout<<endl;
 19 |     
 20 |     vector<ll> d(n);
 21 |     for(ll i=0;i<n;i++)
 22 |     {
 23 |         cin>>d[i];
 24 |         
 25 |     }
 26 |  
 27 |     return d;
 28 |     
 29 | }
 30 |  
 31 | int main()
 32 | {
 33 |     
 34 |     cin>>n;
 35 |     vector<ll> dl=ask(0);
 36 |     ll cnto=0,cnte=0;
 37 |     for(ll i=0;i<n;i++)
 38 |     {
 39 |         if(dl[i]%2==0)
 40 |         {
 41 |             cnte++;
 42 |         }else
 43 |         {
 44 |             cnto++;
 45 |         }
 46 |     }
 47 |     
 48 |     if(cnto>=cnte)
 49 |     {
 50 |         
 51 |         for(ll i=0;i<n;i++)
 52 |         {
 53 |             if(dl[i]%2==0)
 54 |             {
 55 |                 vector<ll> vs(n);
 56 |                 if(i==0)
 57 |                 {
 58 |                     vs=dl;
 59 |                 }else
 60 |                 {
 61 |                     vs=ask(i);
 62 |                 }
 63 |                 for(ll j=0;j<n;j++)
 64 |                 {
 65 |                     if(vs[j]==1)
 66 |                     {
 67 |                         ans.push_back(make_pair(i+1,j+1));
 68 |                     }
 69 |                 }
 70 |                 
 71 |             }
 72 |         }
 73 |     }else
 74 |     {
 75 |         for(ll i=0;i<n;i++)
 76 |         {
 77 |             if(dl[i]%2==1)
 78 |             {
 79 |                 vector<ll> vs(n);
 80 |                 if(i==0)
 81 |                 {
 82 |                     vs=dl;
 83 |                 }else
 84 |                 {
 85 |                     vs=ask(i);
 86 |                 }
 87 |                 for(ll j=0;j<n;j++)
 88 |                 {
 89 |                     if(vs[j]==1)
 90 |                     {
 91 |                         ans.push_back(make_pair(i+1,j+1));
 92 |                     }
 93 |                 }
 94 |                 
 95 |             }
 96 |         }
 97 |     }
 98 |  
 99 |  
100 |     cout<<"!"<<endl;
101 |     for(ll i=0;i<ans.size();i++)
102 |     {
103 |         cout<<ans[i].first<<" "<<ans[i].second<<endl;
104 |     }
105 |  
106 |     
107 |  
108 |     return 0;
109 | }
110 | 


--------------------------------------------------------------------------------
/Interactive problems/9.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sun shine, give me some rain, give me some little more chance to grow up once again 
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 |  
 9 | #define ll long long
10 | #define mod 1000000007
11 |  
12 |  
13 | ll ask(ll l, ll r)
14 | {
15 |     if (l >= r) 
16 |     {
17 |         return -1;
18 |     }
19 |     cout<<"? "<<l+1<<" "<<r+1<<endl;
20 |     ll val;
21 |     cin>>val;
22 |     return val-1;
23 | }
24 |  
25 | int main()
26 | {
27 |     ll n;
28 |     cin>>n;
29 |     ll smax;
30 |     smax=ask(0,n-1);
31 |     ll l,r;
32 |     if(smax==0 || ask(0,smax)!=smax)
33 |     {
34 |         l=smax;
35 |         r=n-1;
36 |         ll m;
37 |         
38 |         while(r-l>1)
39 |         {
40 |             m=(l+r)/2;
41 |             if(ask(smax,m)==smax)
42 |             {
43 |                 r=m;
44 |             }else
45 |             {
46 |                 l=m;
47 |             }
48 |         }
49 |         cout<<"! "<<r+1<<endl;
50 |     }else
51 |     {
52 |         l=0;
53 |         r=smax;
54 |         ll m;
55 |         
56 |         while(r-l>1)
57 |         {
58 |             m=(l+r)/2;
59 |             if(ask(m,smax)==smax)
60 |             {
61 |                 l=m;
62 |             }else
63 |             {
64 |                 r=m;
65 |             }
66 |         }
67 |         cout<<"! "<<l+1<<endl;
68 |  
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/Interactive problems/README.MD:
--------------------------------------------------------------------------------
 1 | Interactive problems are basically very interesting part of programming they are easy to approach. 
 2 |   https://codeforces.com/blog/entry/45307
 3 |   
 4 | # practice problems:-   
 5 |   1. https://codeforces.com/problemset/problem/1665/D  
 6 |   2. https://codeforces.com/problemset/problem/1634/D  
 7 |   3. https://codeforces.com/problemset/problem/1621/C  
 8 |   4. https://codeforces.com/problemset/problem/1617/D1  
 9 |   5. https://codeforces.com/problemset/problem/1617/D2  
10 |   6. https://codeforces.com/problemset/problem/1583/D  
11 |   7. https://codeforces.com/problemset/problem/1556/D  
12 |   8. https://codeforces.com/problemset/problem/1534/D  
13 |   9. https://codeforces.com/problemset/problem/1486/C1  
14 |   10. https://codeforces.com/problemset/problem/1486/C2  
15 |   11. https://codeforces.com/contest/1688/problem/E
16 |   12. https://codeforces.com/contest/1697/problem/D 
17 |     
18 |     
19 |     
20 |     
21 | # format to solve interactive problems :
22 |     
23 |       data_type Query_Fucntion(arguments){
24 |           cout<<"? "<<arguments;
25 |           data_type in;
26 |           cin>>in;
27 |           return in;
28 |       }
29 |       
30 |       
31 |  
32 | by using above function you can ask queries. 
33 |     
34 | Always look for maximum queries and constraint you may get a hint from there how to approach problem.
35 | In CF round interactive problems almost every time rated above 1800 and if you know about interactive problems and think a little bit and code it smoothly you will get AC.
36 |     
37 |     
38 |     
39 |     
40 |     
41 | 


--------------------------------------------------------------------------------
/RANGE Queries/README.MD:
--------------------------------------------------------------------------------
1 | source for segment trees:  
2 | https://codeforces.com/edu/course/2  
3 | https://cp-algorithms.com/data_structures/segment_tree.html 
4 | 
5 | 
6 | other rangeQueries data structure(sparse table): 
7 | https://cp-algorithms.com/data_structures/sparse-table.html
8 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1143-HotelQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | vector<ll> seg(800005,0);
15 | 
16 | 
17 | void set1(ll i,ll val,ll x,ll l,ll r){
18 |     if(r-l==1){
19 |         seg[x]=val;
20 |         return ;
21 |     }
22 | 
23 |     ll mid=(l+r)/2;
24 | 
25 |     if(i<mid){
26 |         set1(i,val,2*x+1,l,mid);
27 |     }else{
28 |         set1(i,val,2*x+2,mid,r);
29 |     }
30 | 
31 |     seg[x]=max(seg[2*x+1],seg[2*x+2]);
32 | }
33 | 
34 | ll in(ll val,ll x,ll l,ll r){
35 |     if(r-l==1){
36 |         return l;
37 |     }
38 | 
39 |     ll mid=(l+r)/2;
40 | 
41 |     if(seg[2*x+1]>=val){
42 |         return in(val,2*x+1,l,mid);
43 |     }
44 |     return in(val,2*x+2,mid,r);
45 | }
46 | 
47 | 
48 | 
49 | 
50 | int main()
51 | {
52 | 
53 |     ios_base::sync_with_stdio(false);
54 |     
55 |     cin.tie(NULL);
56 |     
57 | 
58 |     ll n,q;
59 |     cin>>n>>q;
60 |     ll arr[n];
61 |     for(ll i=0;i<n;i++)
62 |     {
63 |         cin>>arr[i];
64 |         set1(i,arr[i],0,0,n);
65 | 
66 |     }
67 | 
68 |     // for(ll i=0;i<2*n-1;i++){
69 |         // cout<<seg[i]<<" ";
70 |     // }
71 |     // cout<<endl;
72 | 
73 | 
74 | 
75 |     while(q--){
76 |         ll v;
77 |         cin>>v;
78 |         if(seg[0]<v){
79 |             cout<<"0"<<" ";
80 |             continue;
81 |         }
82 |         ll i=in(v,0,0,n);
83 |         arr[i]-=v;
84 |         set1(i,arr[i],0,0,n);
85 |         i++;
86 |         cout<<i<<" ";
87 |     }
88 |     cout<<endl;
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1190-SubarraySumQueries.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | #include <bits/stdc++.h>
 10 | using namespace std;
 11 | 
 12 | #define ll long long
 13 | 
 14 | 
 15 | struct node{
 16 |     ll prefix,suffix,mx,total;
 17 | };
 18 | 
 19 | vector<node> seg(800005, {0,0,0,0});
 20 | 
 21 | 
 22 | node merge(node a,node b){
 23 |     node c;
 24 |     c.prefix=max(a.total+b.prefix,a.prefix);
 25 |     c.suffix=max(a.suffix+b.total,b.suffix);
 26 |     c.total=a.total+b.total;
 27 |     c.mx=max(a.mx,b.mx);
 28 |     c.mx=max(c.mx,c.suffix);
 29 |     c.mx=max(c.mx,c.prefix);
 30 |     c.mx=max(c.mx,a.suffix+b.prefix);
 31 |     return c;
 32 | }
 33 | 
 34 | 
 35 | 
 36 | void set1(ll i,ll val,ll x,ll l,ll r){
 37 |     if(r-l==1){
 38 |         seg[x].total=val;
 39 |         seg[x].mx=max(0ll,val);
 40 |         seg[x].prefix=max(0ll,val);
 41 |         seg[x].suffix=max(0ll,val);
 42 |         return ;
 43 |     }
 44 |     ll mid=(l+r)/2;
 45 | 
 46 |     if(i<mid){
 47 |         set1(i,val,2*x+1,l,mid);
 48 |     }else{
 49 |         set1(i,val,2*x+2,mid,r);
 50 |     }
 51 |     seg[x]=merge(seg[2*x+1],seg[2*x+2]);
 52 | }
 53 | 
 54 | 
 55 | node ans(ll l,ll r,ll x,ll lf,ll rf){
 56 |     if(lf>=l && rf<=r){
 57 |         return seg[x];
 58 |     }else if(lf>=r || rf<=l){
 59 |         return {0,0,0,0};
 60 |     }
 61 |     ll mid=(lf+rf)/2;
 62 |     return merge(ans(l,r,2*x+1,lf,mid),ans(l,r,2*x+2,mid,rf));
 63 | }
 64 | 
 65 | 
 66 | 
 67 | 
 68 | 
 69 | int main()
 70 | {
 71 | 
 72 |     ios_base::sync_with_stdio(false);
 73 | 
 74 |     cin.tie(NULL);
 75 | 
 76 |     ll n, q;
 77 |     cin >> n >> q;
 78 |     
 79 |     for (ll i = 0; i < n; i++)
 80 |     {
 81 |         ll x;
 82 |         cin>>x;
 83 | 
 84 |         set1(i,x,0,0,n);
 85 |     }
 86 | 
 87 |     while(q--){
 88 |             ll i,u;
 89 |             cin>>i>>u;
 90 |             i--;
 91 |             set1(i,u,0,0,n);
 92 |             
 93 |         
 94 |     
 95 |         node an=ans(0,n,0,0,n);
 96 |         cout<<an.mx<<endl;
 97 |     }
 98 |     return 0;
 99 | }
100 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1646-staticRangeSumQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | int main()
15 | {
16 |  
17 |     ios_base::sync_with_stdio(false);
18 |     cin.tie(NULL);
19 |     ll n,q;
20 |     cin>>n>>q;
21 |     ll arr[n+1];
22 |     arr[0]=0;
23 |     for(ll i=1;i<=n;i++)
24 |     {
25 |         cin>>arr[i];
26 |         arr[i]+=arr[i-1];
27 |     }
28 |     while(q--){
29 |         ll l,r;
30 |         cin>>l>>r;
31 |         l--;
32 |         ll ans=arr[r]-arr[l];
33 |         cout<<ans<<endl;
34 |     }
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1647-StaticRangeMinQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | // ll st[200005][25];
16 | vector<vector<ll>> st(200005,vector<ll>(25,INT_MAX));
17 | 
18 | int main()
19 | {
20 | 
21 |     ios_base::sync_with_stdio(false);
22 |     
23 |     cin.tie(NULL);
24 |     
25 | 
26 |     ll n,q;
27 |     cin>>n>>q;
28 |     ll arr[n+1];
29 |     // cout<<st[1][1]<<endl;
30 |     for(ll i=1;i<=n;i++)
31 |     {
32 |         cin>>arr[i];
33 |         st[i][0]=arr[i];
34 |     }
35 | 
36 | 
37 |     for(ll i=1;i<25;i++){
38 |         for(ll j=1;(j+(1<<i))<=n+1;j++){
39 |             st[j][i]=min(st[j][i-1],st[j+(1<<(i-1))][i-1]);
40 |         }
41 |     }
42 | 
43 | 
44 | 
45 | 
46 | 
47 |     while(q--){
48 |         ll l,r;
49 |         cin>>l>>r;
50 |         ll ans=st[l][0];
51 |         for(ll i=24;i>=0;i--){
52 |             if(((l+(1<<i))-1)<=r){
53 |                 // cout<<i<<" i"<<endl;
54 |                 ans=min(ans,st[l][i]);
55 |                 l+=(1<<i);
56 |             }
57 |         }
58 |         cout<<ans<<endl;
59 |         
60 |     }
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1648-DynamicRangeSumQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | // ll st[200005][25];
16 | vector<ll> seg(800005,0);
17 | 
18 | void st(ll i,ll val,ll x,ll l,ll r){
19 |     if(r-l==1){
20 |         seg[x]=val;
21 |         return ;
22 |     }
23 |     ll mid=(l+r)/2;
24 |     if(i<mid){
25 |         st(i,val,2*x+1,l,mid);
26 |     }else{
27 |         st(i,val,2*x+2,mid,r);
28 |     }
29 |     seg[x]=seg[2*x+1]+seg[2*x+2];
30 | }
31 | 
32 | 
33 | ll sum(ll l,ll r,ll x,ll lf,ll rf){
34 |     if(lf>=l && r>=rf){
35 |         return seg[x];
36 |     }else if(lf>=r || rf<=l){
37 |         return 0;
38 |     }
39 |     ll mid=(lf+rf)/2;
40 | 
41 |     return sum(l,r,2*x+1,lf,mid)+sum(l,r,2*x+2,mid,rf);
42 | 
43 | }
44 | 
45 | int main()
46 | {
47 | 
48 |     ios_base::sync_with_stdio(false);
49 |     
50 |     cin.tie(NULL);
51 |     
52 | 
53 |     ll n,q;
54 |     cin>>n>>q;
55 |     // cout<<"YES"<<endl;
56 |     
57 |     for(ll i=0;i<n;i++)
58 |     {
59 |         ll x;
60 |         cin>>x;
61 |         st(i,x,0,0,n);
62 |     }
63 |     // cout<<"YES"<<endl;
64 | 
65 |     while(q--){
66 |         ll tp;
67 |         cin>>tp;
68 |         if(tp==1){
69 |             ll i,val;
70 |             cin>>i>>val;
71 |             i--;
72 |             st(i,val,0,0,n);
73 |             continue;
74 |         }
75 |         ll l,r;
76 |         cin>>l>>r;
77 |         l--;
78 |         // r--;
79 |         ll ans=sum(l,r,0,0,n);
80 |         cout<<ans<<endl;
81 |         
82 |     }
83 |     return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1649-DynamicRangeMinQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | // ll st[200005][25];
16 | vector<ll> seg(800005,INT_MAX);
17 | 
18 | void st(ll i,ll val,ll x,ll l,ll r){
19 |     if(r-l==1){
20 |         seg[x]=val;
21 |         return ;
22 |     }
23 |     ll mid=(l+r)/2;
24 |     if(i<mid){
25 |         st(i,val,2*x+1,l,mid);
26 |     }else{
27 |         st(i,val,2*x+2,mid,r);
28 |     }
29 |     seg[x]=min(seg[2*x+1],seg[2*x+2]);
30 | }
31 | 
32 | 
33 | ll sum(ll l,ll r,ll x,ll lf,ll rf){
34 |     if(lf>=l && r>=rf){
35 |         return seg[x];
36 |     }else if(lf>=r || rf<=l){
37 |         return INT_MAX;
38 |     }
39 |     ll mid=(lf+rf)/2;
40 | 
41 |     return min(sum(l,r,2*x+1,lf,mid),sum(l,r,2*x+2,mid,rf));
42 | 
43 | }
44 | 
45 | int main()
46 | {
47 | 
48 |     ios_base::sync_with_stdio(false);
49 |     
50 |     cin.tie(NULL);
51 |     
52 | 
53 |     ll n,q;
54 |     cin>>n>>q;
55 |     // cout<<"YES"<<endl;
56 |     
57 |     for(ll i=0;i<n;i++)
58 |     {
59 |         ll x;
60 |         cin>>x;
61 |         st(i,x,0,0,n);
62 |     }
63 |     // cout<<"YES"<<endl;
64 | 
65 |     while(q--){
66 |         ll tp;
67 |         cin>>tp;
68 |         if(tp==1){
69 |             ll i,val;
70 |             cin>>i>>val;
71 |             i--;
72 |             st(i,val,0,0,n);
73 |             continue;
74 |         }
75 |         ll l,r;
76 |         cin>>l>>r;
77 |         l--;
78 |         // r--;
79 |         ll ans=sum(l,r,0,0,n);
80 |         cout<<ans<<endl;
81 |         
82 |     }
83 |     return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1650-RangeXorQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | // ll st[200005][25];
16 | vector<ll> seg(800005,0);
17 | 
18 | void st(ll i,ll val,ll x,ll l,ll r){
19 |     if(r-l==1){
20 |         seg[x]=val;
21 |         return ;
22 |     }
23 |     ll mid=(l+r)/2;
24 |     if(i<mid){
25 |         st(i,val,2*x+1,l,mid);
26 |     }else{
27 |         st(i,val,2*x+2,mid,r);
28 |     }
29 |     seg[x]=seg[2*x+1]^seg[2*x+2];
30 | }
31 | 
32 | 
33 | ll sum(ll l,ll r,ll x,ll lf,ll rf){
34 |     if(lf>=l && r>=rf){
35 |         return seg[x];
36 |     }else if(lf>=r || rf<=l){
37 |         return 0;
38 |     }
39 |     ll mid=(lf+rf)/2;
40 | 
41 |     return sum(l,r,2*x+1,lf,mid)^sum(l,r,2*x+2,mid,rf);
42 | 
43 | }
44 | 
45 | int main()
46 | {
47 | 
48 |     ios_base::sync_with_stdio(false);
49 |     
50 |     cin.tie(NULL);
51 |     
52 | 
53 |     ll n,q;
54 |     cin>>n>>q;
55 |     // cout<<"YES"<<endl;
56 |     
57 |     for(ll i=0;i<n;i++)
58 |     {
59 |         ll x;
60 |         cin>>x;
61 |         st(i,x,0,0,n);
62 |     }
63 |     // cout<<"YES"<<endl;
64 | 
65 |     while(q--){
66 |        
67 |         ll l,r;
68 |         cin>>l>>r;
69 |         l--;
70 |         // r--;
71 |         ll ans=sum(l,r,0,0,n);
72 |         cout<<ans<<endl;
73 |         
74 |     }
75 |     return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1651-RangeUpdateQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | // ll st[200005][25];
16 | vector<ll> seg(800005,0);
17 | 
18 | ll st(ll i,ll x,ll l,ll r){
19 |     if(r-l==1){
20 |         return seg[x];
21 |     }
22 |     ll mid=(l+r)/2;
23 |     if(i<mid){
24 |         
25 |         return seg[x]+st(i,2*x+1,l,mid);
26 |     }
27 |     
28 |     return seg[x]+st(i,2*x+2,mid,r);
29 |     
30 | }
31 | 
32 | 
33 | void set1(ll l,ll r,ll val,ll x,ll lf,ll rf){
34 |     if(lf>=l && r>=rf){
35 |         seg[x]+=val;
36 |         return ;
37 |     }else if(lf>=r || rf<=l){
38 |         return;
39 |     }
40 |     ll mid=(lf+rf)/2;
41 | 
42 |     set1(l,r,val,2*x+1,lf,mid);
43 |     set1(l,r,val,2*x+2,mid,rf);
44 | 
45 | }
46 | 
47 | int main()
48 | {
49 | 
50 |     ios_base::sync_with_stdio(false);
51 |     
52 |     cin.tie(NULL);
53 |     
54 | 
55 |     ll n,q;
56 |     cin>>n>>q;
57 |     // cout<<"YES"<<endl;
58 |     
59 |     for(ll i=0;i<n;i++)
60 |     {
61 |         ll x;
62 |         cin>>x;
63 |         set1(i,i+1,x,0,0,n);
64 |     }
65 |     // cout<<"YES"<<endl;
66 | 
67 |     // for(ll i=0;i<2n-1;i++){
68 |     //     cout<<seg[i]<<" ";
69 |     // }
70 |     // cout<<endl;*
71 | 
72 |     while(q--){
73 |         ll tp;
74 |         cin>>tp;
75 |         if(tp==1){
76 |             ll a,b,u;
77 |             cin>>a>>b>>u;
78 |             a--;
79 |             set1(a,b,u,0,0,n);
80 |             continue;
81 |         }
82 |         ll i;
83 |         cin>>i;
84 |         i--;
85 |         ll ans=st(i,0,0,n);
86 |         cout<<ans<<endl;
87 |         
88 |     }
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1652-ForestQueries.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | 
15 | 
16 | int main()
17 | {
18 | 
19 |     ios_base::sync_with_stdio(false);
20 |     
21 |     cin.tie(NULL);
22 |     
23 | 
24 |     ll n,q;
25 |     cin>>n>>q;
26 |     // cout<<"YES"<<endl;
27 |     vector<vector<ll>> vec(n+1,vector<ll>(n+1,0));
28 |     for(ll i=0;i<n;i++)
29 |     {
30 |         string s;
31 |         cin>>s;
32 |         for(ll j=0;j<n;j++){
33 |             if(s[j]=='*'){
34 |                 vec[i+1][j+1]=1;
35 |             }else{
36 |                 vec[i+1][j+1]=0;
37 |             }
38 |         }
39 | 
40 |     }
41 | 
42 |     for(ll i=1;i<=n;i++){
43 |         for(ll j=1;j<=n;j++){
44 |             // vec[i][j]+=vec[i-1][j];
45 |             vec[i][j]+=vec[i][j-1];
46 |         }
47 |     }
48 | 
49 |     for(ll i=1;i<=n;i++){
50 |         for(ll j=1;j<=n;j++){
51 |             vec[i][j]+=vec[i-1][j];
52 |         }
53 |     }
54 |     // for(ll i=1;i<=n;i++){
55 |     //     for(ll j=1;j<=n;j++){
56 |     //         cout<<vec[i][j]<<" ";
57 |     //     }
58 |     //     cout<<endl;
59 |     // }
60 | 
61 | 
62 | 
63 |     while(q--){
64 |         ll y1,x1,y2,x2;
65 |         cin>>y1>>x1>>y2>>x2;
66 |         ll ans=vec[y2][x2]-vec[y1-1][x2]-vec[y2][x1-1]+vec[y1-1][x1-1];
67 |         cout<<ans<<endl;
68 |         
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/1749-ListRemovals.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | vector<ll> seg(800005,0);
15 | 
16 | 
17 | void set1(ll i,ll val,ll x,ll l,ll r){
18 |     if(r-l==1){
19 |         seg[x]=val;
20 |         return ;
21 |     }
22 | 
23 |     ll mid=(l+r)/2;
24 | 
25 |     if(i<mid){
26 |         set1(i,val,2*x+1,l,mid);
27 |     }else{
28 |         set1(i,val,2*x+2,mid,r);
29 |     }
30 | 
31 |     seg[x]=seg[2*x+1]+seg[2*x+2];
32 | }
33 | ll vll=0;
34 | ll in(ll val,ll x,ll l,ll r){
35 |     if(r-l==1){
36 |         return l;
37 |     }
38 | 
39 |     ll mid=(l+r)/2;
40 | 
41 |     if(vll+seg[2*x+1]>=val){
42 |         return in(val,2*x+1,l,mid);
43 |     }
44 |     vll+=seg[2*x+1];
45 |     return in(val,2*x+2,mid,r);
46 | 
47 | }
48 | 
49 | 
50 | 
51 | 
52 | int main()
53 | {
54 | 
55 |     ios_base::sync_with_stdio(false);
56 |     
57 |     cin.tie(NULL);
58 |     
59 | 
60 |     ll n;
61 |     cin>>n;
62 |     ll arr[n];
63 |     for(ll i=0;i<n;i++)
64 |     {
65 |         cin>>arr[i];
66 |         set1(i,1,0,0,n);
67 | 
68 |     }
69 | 
70 |     // for(ll i=0;i<2*n-1;i++){
71 |     //     cout<<seg[i]<<" ";
72 |     // }
73 |     // cout<<endl;
74 | 
75 | 
76 |     ll q=n;
77 |     while(q--){
78 |         ll v;
79 |         cin>>v;
80 |         vll=0;
81 |         
82 |         ll i=in(v,0,0,n);
83 |         // cout<<i<<" i";
84 |         
85 |         cout<<arr[i]<<" ";
86 | 
87 |         set1(i,0,0,0,n);
88 |     }
89 |     cout<<endl;
90 |     return 0;
91 | }
92 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/2166-PrefixSumQueries.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | #include <bits/stdc++.h>
 10 | using namespace std;
 11 | 
 12 | #define ll long long
 13 | 
 14 | 
 15 | struct node{
 16 |     ll prefix,suffix,mx,total;
 17 | };
 18 | 
 19 | vector<node> seg(800005, {0,0,0,0});
 20 | 
 21 | 
 22 | node merge(node a,node b){
 23 |     node c;
 24 |     c.prefix=max(a.total+b.prefix,a.prefix);
 25 |     c.suffix=max(a.suffix+b.total,b.suffix);
 26 |     c.total=a.total+b.total;
 27 |     c.mx=max(a.mx,b.mx);
 28 |     c.mx=max(c.mx,c.suffix);
 29 |     c.mx=max(c.mx,c.prefix);
 30 |     c.mx=max(c.mx,a.suffix+b.prefix);
 31 |     return c;
 32 | }
 33 | 
 34 | 
 35 | 
 36 | void set1(ll i,ll val,ll x,ll l,ll r){
 37 |     if(r-l==1){
 38 |         seg[x].total=val;
 39 |         seg[x].mx=max(0ll,val);
 40 |         seg[x].prefix=max(0ll,val);
 41 |         seg[x].suffix=max(0ll,val);
 42 |         return ;
 43 |     }
 44 |     ll mid=(l+r)/2;
 45 | 
 46 |     if(i<mid){
 47 |         set1(i,val,2*x+1,l,mid);
 48 |     }else{
 49 |         set1(i,val,2*x+2,mid,r);
 50 |     }
 51 |     seg[x]=merge(seg[2*x+1],seg[2*x+2]);
 52 | }
 53 | 
 54 | 
 55 | node ans(ll l,ll r,ll x,ll lf,ll rf){
 56 |     if(lf>=l && rf<=r){
 57 |         return seg[x];
 58 |     }else if(lf>=r || rf<=l){
 59 |         return {0,0,0,0};
 60 |     }
 61 |     ll mid=(lf+rf)/2;
 62 |     return merge(ans(l,r,2*x+1,lf,mid),ans(l,r,2*x+2,mid,rf));
 63 | }
 64 | 
 65 | 
 66 | 
 67 | 
 68 | 
 69 | int main()
 70 | {
 71 | 
 72 |     ios_base::sync_with_stdio(false);
 73 | 
 74 |     cin.tie(NULL);
 75 | 
 76 |     ll n, q;
 77 |     cin >> n >> q;
 78 |     
 79 |     for (ll i = 0; i < n; i++)
 80 |     {
 81 |         ll x;
 82 |         cin>>x;
 83 | 
 84 |         set1(i,x,0,0,n);
 85 |     }
 86 | 
 87 |     while(q--){
 88 |         ll tp;
 89 |         cin>>tp;
 90 |         if(tp==1){
 91 |             ll i,u;
 92 |             cin>>i>>u;
 93 |             i--;
 94 |             set1(i,u,0,0,n);
 95 |             continue;
 96 |         }
 97 |         ll a,b;
 98 |         cin>>a>>b;
 99 |         a--;
100 |         
101 |         node an=ans(a,b,0,0,n);
102 |         cout<<an.prefix<<endl;
103 |     }
104 |     return 0;
105 | }
106 | 


--------------------------------------------------------------------------------
/RANGE Queries/cses/2206-PizzeriaQueries.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | #include <bits/stdc++.h>
 10 | using namespace std;
 11 | 
 12 | #define ll long long
 13 | 
 14 | 
 15 | vector<ll> seg(800005,INT_MAX);
 16 | vector<ll> seg1(800005,INT_MAX);
 17 | 
 18 | 
 19 | 
 20 | 
 21 | void set1(ll i,ll val,ll x,ll l,ll r){
 22 |     if(r-l==1){
 23 |         seg[x]=val;
 24 |         return ;
 25 |     }
 26 |     ll mid=(l+r)/2;
 27 | 
 28 |     if(i<mid){
 29 |         set1(i,val,2*x+1,l,mid);
 30 | 
 31 |         
 32 |     }else{
 33 |         set1(i,val,2*x+2,mid,r);
 34 |     }
 35 | 
 36 |     seg[x]=min(seg[2*x+1],mid-l+seg[2*x+2]);
 37 | }
 38 | 
 39 | 
 40 | ll ans(ll i,ll x,ll lf,ll rf){
 41 | 
 42 |     if(rf-lf==1){
 43 |         return seg[x];
 44 |     }
 45 |     ll mid=(lf+rf)/2;
 46 | 
 47 |     if(i<mid){
 48 |         return min(ans(i,2*x+1,lf,mid),seg[2*x+2]+mid-i);
 49 |     }
 50 |     return ans(i,2*x+2,mid,rf);
 51 | }
 52 | 
 53 | 
 54 | void set2(ll i,ll val,ll x,ll l,ll r){
 55 |     if(r-l==1){
 56 |         seg1[x]=val;
 57 |         return ;
 58 |     }
 59 |     ll mid=(l+r)/2;
 60 | 
 61 |     if(i<mid){
 62 |         set2(i,val,2*x+1,l,mid);
 63 | 
 64 |     }else{
 65 |         set2(i,val,2*x+2,mid,r);
 66 | 
 67 |     }
 68 |     seg1[x]=min(seg1[2*x+1],mid-l+seg1[2*x+2]);
 69 | 
 70 | 
 71 | }
 72 | 
 73 | 
 74 | ll ans1(ll i,ll x,ll lf,ll rf){
 75 | 
 76 |     if(rf-lf==1){
 77 |         return seg1[x];
 78 |     }
 79 |     ll mid=(lf+rf)/2;
 80 | 
 81 |     if(i<mid){
 82 |         return min(ans1(i,2*x+1,lf,mid),seg1[2*x+2]+mid-i);
 83 |     }
 84 |     return ans1(i,2*x+2,mid,rf);
 85 | }
 86 | 
 87 | 
 88 | 
 89 | int main()
 90 | {
 91 | 
 92 |     ios_base::sync_with_stdio(false);
 93 | 
 94 |     cin.tie(NULL);
 95 | 
 96 |     ll n, q;
 97 |     cin >> n >> q;
 98 |     
 99 |     for (ll i = 0; i < n; i++)
100 |     {
101 |         ll x;
102 |         cin>>x;
103 | 
104 |         
105 | 
106 |         set1(i,x,0,0,n);
107 |         set2(n-i-1,x,0,0,n);
108 |     }
109 | 
110 |     while(q--){
111 | 
112 |         ll tp;
113 |         cin>>tp;
114 |         if(tp==1){
115 |             ll i,val;
116 |             cin>>i>>val;
117 |             i--;
118 |             set1(i,val,0,0,n);
119 |             set2(n-i-1,val,0,0,n);
120 |             continue;
121 |         }
122 | 
123 |         ll x;
124 |         cin>>x;
125 | 
126 |         x--;
127 |         ll an=ans(x,0,0,n);
128 |         ll an1=ans1(n-x-1,0,0,n);
129 |         an=min(an,an1);
130 |         cout<<an<<endl;
131 | 
132 | 
133 |     }
134 |     return 0;
135 | }
136 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Competitive-Programming
 2 | 
 3 | profiles:
 4 | 
 5 | codeforces: https://codeforces.com/profile/manitianajay45  
 6 | codechef: https://www.codechef.com/users/manitianajay45  
 7 | cses: https://cses.fi/user/109927       
 8 | Atcoder: https://atcoder.jp/users/manitianajay45
 9 |    
10 | 


--------------------------------------------------------------------------------
/String Algorithms/CSES/1731-WordCombinations.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chacne to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | #include<bits/stdc++.h>
 10 | using namespace std;
 11 | 
 12 | #define ll long long
 13 | 
 14 | #define mod 1000000007
 15 | 
 16 | struct TrieNode{
 17 |     struct TrieNode *child[26];
 18 |     bool isend;
 19 | 
 20 |     TrieNode(){
 21 |         isend=false;
 22 | 
 23 |         for(ll i=0;i<26;i++){
 24 |             child[i]=NULL;
 25 |         }
 26 |     }
 27 | };
 28 | 
 29 | 
 30 | 
 31 | void insert(string s,struct TrieNode *root){
 32 |     struct TrieNode *curr= root;
 33 | 
 34 |     ll n=s.length();
 35 |     for(ll i=0;i<n;i++){
 36 |         ll in=s[i]-'a';
 37 |         if(curr->child[in]==NULL){
 38 |             curr->child[in]=new TrieNode();
 39 |         }
 40 | 
 41 |         curr=curr->child[in];
 42 | 
 43 |     }
 44 | 
 45 |     curr->isend=true;
 46 | }
 47 | 
 48 | 
 49 | 
 50 | 
 51 | int main(){
 52 |     
 53 |     string s;
 54 |     cin>>s;
 55 |     ll n=s.length();
 56 | 
 57 |     ll k;
 58 |     cin>>k;
 59 |     struct TrieNode *root = new TrieNode();
 60 |     for(ll i=0;i<k;i++){
 61 |         string dic;
 62 |         cin>>dic;
 63 |         reverse(dic.begin(),dic.end());
 64 |         insert(dic,root);
 65 | 
 66 | 
 67 |     }
 68 | 
 69 | 
 70 |     vector<ll> dp(n+1,0);
 71 |     dp[0]=1;
 72 | 
 73 |     for(ll i=1;i<=n;i++){
 74 |         string ss="";
 75 |         struct TrieNode *curr =root;
 76 | 
 77 |         for(ll j=i;j>=1;j--){
 78 |             char ch=s[j-1];
 79 |             // cout<<ss<<endl;
 80 |             // cout<<ch<<endl;
 81 | 
 82 |             ll in=ch-'a';
 83 | 
 84 |             if(curr->child[in]==NULL){
 85 |                 break;
 86 |             }
 87 |             curr=curr->child[in];
 88 |             if(curr->isend){
 89 |                 // cout<<"YES"<<endl;
 90 |                 // cout<<j<<endl;
 91 |                 dp[i]+=dp[j-1];
 92 |                 dp[i]%=mod;
 93 |             }
 94 | 
 95 | 
 96 |         }
 97 | 
 98 | 
 99 |     }
100 |     cout<<dp[n]<<endl;
101 | }
102 | 


--------------------------------------------------------------------------------
/String Algorithms/CSES/1732-FindingBorders.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chacne to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | #define mod 1000000007
15 | 
16 | 
17 | int main(){
18 |     string s;
19 |     cin>>s;
20 |     ll n=s.length();
21 | 
22 |     ll x=0;
23 |     ll y=0;
24 |     vector<ll> zrr(n,0);
25 |     s+='*';
26 |     for(ll i=1;i<n;i++){
27 |         zrr[i]=max(0ll,min(zrr[i-x],(y-i+1)));
28 | 
29 |         while(i+zrr[i]<n && s[zrr[i]]==s[i+zrr[i]]){
30 |             
31 |             x=i;
32 |             y=i+zrr[i];
33 |             zrr[i]++;
34 |         }
35 | 
36 |     }
37 |     // for(ll i=0;i<n;i++){
38 |     //     cout<<zrr[i]<<" ";
39 |     // }
40 |     // cout<<endl;
41 | 
42 |     for(ll i=n-1;i>=1;i--){
43 |         if(i+zrr[i]==n){
44 |             cout<<zrr[i]<<" ";
45 |         }
46 |     }
47 |     cout<<endl;
48 | 
49 | 
50 |     return 0;
51 |     
52 | }
53 | 


--------------------------------------------------------------------------------
/String Algorithms/CSES/1733-FindingPeriods.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chacne to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | #define mod 1000000007
15 | 
16 | 
17 | int main(){
18 |     string s;
19 |     cin>>s;
20 |     ll n=s.length();
21 | 
22 |     ll x=0;
23 |     ll y=0;
24 |     vector<ll> zrr(n,0);
25 |     s+='*';
26 |     for(ll i=1;i<n;i++){
27 |         zrr[i]=max(0ll,min(zrr[i-x],(y-i+1)));
28 | 
29 |         while(i+zrr[i]<n && s[zrr[i]]==s[i+zrr[i]]){
30 |             
31 |             x=i;
32 |             y=i+zrr[i];
33 |             zrr[i]++;
34 |         }
35 | 
36 |     }
37 |     // for(ll i=0;i<n;i++){
38 |     //     cout<<zrr[i]<<" ";
39 |     // }
40 |     // cout<<endl;
41 | 
42 |     for(ll i=1;i<=n-1;i++){
43 |         ll j=i;
44 |         bool flag=true;
45 |         while(j<n){
46 |             if(zrr[j]<i && (j+zrr[j])<n){
47 |                 flag=false;
48 |                 break;
49 |             }
50 |             j+=i;
51 |         }
52 |         if(flag){
53 |             cout<<i<<" ";
54 |         }
55 |     }
56 | 
57 |     cout<<n<<endl;
58 | 
59 |     return 0;
60 |     
61 | }
62 | 


--------------------------------------------------------------------------------
/String Algorithms/CSES/1753-StringMatching.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chacne to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | #define mod 1000000007
15 | 
16 | 
17 | int main(){
18 |     string s,t;
19 |     cin>>s>>t;
20 |     ll val=t.length();
21 |     t+="#";
22 |     t+=s;
23 |     ll n=t.length();
24 |     vector<ll> dp(n,0);
25 |     dp[0]=0;
26 |     ll ans=0;
27 |     for(ll i=1;i<n;i++){
28 |         
29 |         ll temp=dp[i-1];
30 |         while(temp>0 && t[temp]!=t[i]){
31 |             temp=dp[temp-1];
32 |         }
33 | 
34 |         dp[i]=temp;
35 |         if(t[i]==t[temp]){
36 |             dp[i]++;
37 |         }
38 |         
39 | 
40 |         if(dp[i]==val){
41 |             ans++;
42 |         }
43 |     }
44 |     cout<<ans<<endl;
45 | 
46 | 
47 | 
48 |     
49 | }
50 | 


--------------------------------------------------------------------------------
/String Algorithms/README.MD:
--------------------------------------------------------------------------------
1 | Cp Algorithms:  
2 | https://cp-algorithms.com/string/string-hashing.html
3 | 


--------------------------------------------------------------------------------
/Templates/SieveOfEratosthenes:
--------------------------------------------------------------------------------
 1 | 
 2 |  
 3 |  vector<ll> pmfactor;
 4 |  
 5 | void SieveOfEratosthenes(ll n)
 6 | {
 7 |     vector<bool> prime(n + 1, true);
 8 |     // memset(prime, true, sizeof(prime));
 9 |  
10 |     for (ll p = 2; p * p <= n; p++)
11 |     {
12 |         if (prime[p] == true)
13 |         {
14 |             for (ll i = p * p; i <= n; i += p)
15 |             {
16 |                 prime[i] = false;
17 |             }
18 |         }
19 |     }
20 |  
21 |     prime[1] = true;
22 |  
23 |     // pmfactor.push_back(1);
24 |     for (ll i = 2; i <= n; i++)
25 |     {
26 |         if (prime[i])
27 |         {
28 |             pmfactor.push_back(i);
29 |         }
30 |     }
31 | }
32 |  
33 | 


--------------------------------------------------------------------------------
/Templates/binar_lifting.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | ll dp[200005][20];
 4 | 
 5 | 
 6 | 
 7 | void binlift(){
 8 |     for(ll i=1;i<20;i++){
 9 |         for(ll j=0;j<n;j++){
10 |             if(dp[j][i-1]==-1){
11 |                 dp[j][i]=-1;
12 |                 continue;
13 |             }
14 |             dp[j][i]=dp[dp[j][i-1]][i-1];
15 |         }
16 |     }
17 |  
18 |  
19 | }
20 |  
21 |  
22 | ll query(ll x,ll k){
23 |     ll prev=x;
24 |     for(ll i=20;i>=0;i--){
25 |         if((k>>i)&1){
26 |             // cout<<i<<"i"<<endl;
27 |             prev=dp[prev][i];
28 |             if(prev==-1){
29 |                 break;
30 |             }
31 |  
32 |         }
33 |     }    
34 |     return prev;
35 | }
36 | 
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | int main(){
44 |     ios_base::sync_with_stdio(false);
45 |     cin.tie(NULL);
46 | 
47 | 
48 | 
49 |  
50 | 
51 |     
52 |     memset(dp,-1,sizeof(dp));
53 | 
54 |     for(ll i=0;i<n;i++){
55 |         dp[i][0]=parent[i];
56 |     }
57 | 
58 |     binlift();
59 |    
60 | 
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Templates/ext_gcd.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | ll ext_gcd(ll a, ll b, ll& x, ll& y) 
 3 | {
 4 |     if (b == 0) {
 5 |         x = 1;
 6 |         y = 0;
 7 |         return a;
 8 |     }
 9 |     ll x1, y1;
10 |     ll d = gcd(b, a % b, x1, y1);
11 |     x = y1;
12 |     y = x1 - y1 * (a / b);
13 |     return d;
14 | }
15 | 


--------------------------------------------------------------------------------
/Templates/nCr-2.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #define ll long long
 3 | 
 4 | 
 5 | ll n,m;
 6 | 
 7 | 
 8 | 
 9 | ll power(ll a,ll b,ll mod){
10 |     ll val=a;
11 | 
12 | 
13 |     ll ans=1;
14 | 
15 |     ll temp=b;
16 |     while(temp!=0){
17 |         if(temp%2){
18 |             ans*=(val);
19 |             ans%=mod;
20 |         }
21 |         val*=val;
22 |         val%=mod;
23 |         temp/=2;
24 |     }
25 | 
26 |     return ans;
27 | 
28 | 
29 | 
30 | 
31 | }
32 | 
33 | ll sum(ll x,ll y){
34 | 
35 |     return (x%m + y%m)%m;
36 | 
37 | }
38 | 
39 | 
40 | ll mul(ll x,ll y){
41 | 
42 |     return ((x%m)*(y%m))%m;
43 | 
44 | }
45 | 
46 | 
47 | ll subs(ll x,ll y){
48 |     return (x%m - y%m + m)%m;
49 | }
50 | 
51 | 
52 | 
53 | ll fact[3000005];
54 | ll inver[3000005];
55 | 
56 | void calculate(){
57 |     // cout<<"YES"<<endl;
58 | 
59 |     fact[0]=1;
60 |     fact[0]%=m;
61 | 
62 | 
63 |     for(ll i=1;i<=3000004;i++){
64 |         fact[i]=(fact[i-1]*i)%m;
65 |     }
66 | 
67 |     inver[3000004]=power(fact[3000004],m-2,m);
68 | 
69 |     for(ll i=3000004;i>0;i--){
70 |         inver[i-1]=inver[i]*i;
71 |         inver[i-1]%=m;
72 |     }
73 | 
74 | 
75 | 
76 | }
77 | 
78 | 
79 | ll nCr(ll n,ll r){
80 |     return (((fact[n]*inver[r])%m)*inver[n-r])%m;
81 | }
82 | 


--------------------------------------------------------------------------------
/Templates/nCr-main:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | ll power(ll a,ll b){
 4 |     ll val=a;
 5 | 
 6 | 
 7 |     ll ans=1;
 8 | 
 9 |     ll temp=b;
10 |     while(temp!=0){
11 |         if(temp%2){
12 |             ans*=(val);
13 |             ans%=mod;
14 |         }
15 |         val*=val;
16 |         val%=mod;
17 |         temp/=2;
18 |     }
19 | 
20 |     return ans;
21 | 
22 | 
23 | 
24 | 
25 | }
26 | 
27 | ll sum(ll x,ll y){
28 | 
29 |     return (x%mod + y%mod)%mod;
30 | 
31 | }
32 | 
33 | 
34 | ll mul(ll x,ll y){
35 | 
36 |     return ((x%mod)*(y%mod))%mod;
37 | 
38 | }
39 | 
40 | 
41 | ll subs(ll x,ll y){
42 |     return (x%mod - y%mod + mod)%mod;
43 | }
44 | 
45 | 
46 | 
47 | ll fact[3000005];
48 | ll inver[3000005];
49 | 
50 | void calculate(){
51 |     // cout<<"YES"<<endl;
52 | 
53 |     fact[0]=1;
54 |     fact[0]%=mod;
55 | 
56 | 
57 |     for(ll i=1;i<=3000004;i++){
58 |         fact[i]=(fact[i-1]*i)%mod;
59 |     }
60 | 
61 |     inver[3000004]=power(fact[3000004],mod-2);
62 | 
63 |     for(ll i=3000004;i>0;i--){
64 |         inver[i-1]=inver[i]*i;
65 |         inver[i-1]%=mod;
66 |     }
67 | 
68 | 
69 | 
70 | }
71 | 
72 | 
73 | ll nCr(ll n,ll r){
74 |     return (((fact[n]*inver[r])%mod)*inver[n-r])%mod;
75 | }
76 | 
77 | 


--------------------------------------------------------------------------------
/Templates/nCr.cpp:
--------------------------------------------------------------------------------
 1 | ll fact[500005];
 2 |  
 3 | ll sum(ll x,ll y){
 4 |     return (x%mod + y%mod)%mod;
 5 | }
 6 |  
 7 | ll mul(ll x,ll y){
 8 |     return ((x%mod)*(y%mod))%mod;
 9 | }
10 |  
11 |  
12 | ll modInverse(ll a, ll m)
13 | {
14 |     ll m0 = m;
15 |     ll y = 0, x = 1;
16 |  
17 |     if (m == 1)
18 |         return 0;
19 |  
20 |     while (a > 1) {
21 |         ll q = a / m;
22 |         ll t = m;
23 |         m = a % m, a = t;
24 |         t = y;
25 |         y = (x - mul(q, y)+mod)%mod;
26 |         x = t;
27 |     }
28 |  
29 |     if (x < 0)
30 |         x = sum(x,m0);
31 |  
32 |     return x;
33 | }
34 |  
35 |  
36 | ll ncr(ll n,ll r){
37 |     ll ans=(fact[n]);
38 |     ans=mul(ans,modInverse(fact[n-r],mod));
39 |     ans=mul(ans,modInverse(fact[r],mod));
40 |     return ans;
41 | }
42 | 


--------------------------------------------------------------------------------
/Templates/segtree.cpp:
--------------------------------------------------------------------------------
 1 | #define ll long long
 2 | #define mod 998244353
 3 | 
 4 | vector<ll> seg(800005,-1e17);
 5 | 
 6 | void update(ll i,ll val,ll x,ll l,ll r){
 7 |     if(r-l==1){
 8 |         seg[x]=val;
 9 |         return;
10 |     }
11 |     ll mid=(r+l)/2;
12 |     if(i<mid){
13 |         update(i,val,2*x+1,l,mid);
14 |     }else{
15 |         update(i,val,2*x+2,mid,r);
16 |     }
17 |     seg[x]=max(seg[2*x+1],seg[2*x+2]);
18 | }
19 | 
20 | 
21 | ll query(ll l,ll r,ll x,ll lf,ll rf){
22 |     if(lf>=l && rf<=r){
23 |         return seg[x];
24 |     }else if(rf<=l || lf>=r){
25 |         return -1e17;
26 |     }
27 | 
28 |     ll mid=(lf+rf)/2;
29 |     return max(query(l,r,2*x+1,lf,mid),query(l,r,2*x+2,mid,rf));
30 | }
31 | 


--------------------------------------------------------------------------------
/cses graph/1192 CountingRooms.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | ll n, m;
14 | vector<string> vec(1005);
15 |  
16 | vector<vector<bool>> visited(1005, vector<bool>(1005, false));
17 |  
18 | bool issafe(ll x, ll y)
19 | {
20 |  
21 |     if (x >= 0 && y >= 0 && x <= n - 1 && y <= m - 1 && !visited[x][y] && vec[x][y] == '.')
22 |     {
23 |         return true;
24 |     }
25 |     return false;
26 | }
27 |  
28 | ll xrr[4] = {-1, 0, 0, 1};
29 | ll yrr[4] = {0, -1, 1, 0};
30 |  
31 | int main()
32 | {
33 |     ios_base::sync_with_stdio(false);
34 |     cin.tie(NULL);
35 |     cin >> n >> m;
36 |     for (ll i = 0; i < n; i++)
37 |     {
38 |         string s;
39 |         cin >> s;
40 |         vec[i] = s;
41 |     }
42 |  
43 |     ll ans = 0;
44 |     queue<pair<ll, ll>> q;
45 |  
46 |     for (ll i = 0; i < n; i++)
47 |     {
48 |         for (ll j = 0; j < m; j++)
49 |         {
50 |             
51 |             if (!visited[i][j] && vec[i][j] == '.')
52 |             {
53 |                 
54 |                 bool flag = true;
55 |                 visited[i][j] = true;
56 |                 ans++;
57 |                 q.push({i, j});
58 |  
59 |                 while (!q.empty())
60 |                 {
61 |                     pair<ll,ll> pr=q.front();
62 |                     q.pop();
63 |  
64 |  
65 |                     ll x =pr.first;
66 |                     ll y =pr.second;
67 |  
68 |                     for (ll k = 0; k < 4; k++)
69 |                     {
70 |                         ll X = x + xrr[k];
71 |                         ll Y = y + yrr[k];
72 |                         if (issafe(X, Y))
73 |                         {
74 |                             q.push({X, Y});
75 |                             visited[X][Y] = true;
76 |                         }
77 |                     }
78 |                 }
79 |                 
80 |             }
81 |         }
82 |  
83 |  
84 |     }
85 |  
86 |     // for(ll i=0;i<n;i++){
87 |     //     for(ll j=0;j<m;j++){
88 |     //         cout<<visited[i][j]<<" ";
89 |     //     }
90 |     //     cout<<endl;
91 |     // }
92 |     // cout<<endl;
93 |  
94 |     cout << ans << endl;
95 |     return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/cses graph/1193 Labyrinth.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 |  
  9 | #include <bits/stdc++.h>
 10 | using namespace std;
 11 |  
 12 | #define ll long long
 13 |  
 14 | ll n,m;
 15 | vector<string> grid(1005);
 16 |  
 17 | pair<ll,ll> par[1005][1005];
 18 |  
 19 | bool issafe(ll x,ll y){
 20 |     if(x>=0 && y>=0 && x<n && y<m && (grid[x][y]=='.' || grid[x][y]=='B')){
 21 |         return true;
 22 |     }
 23 |     return false;
 24 | }
 25 |  
 26 | ll xrr[4]={-1,0,1,0};
 27 | ll yrr[4]={0,-1,0,1};
 28 | char ch[4]={'U','L','D','R'};
 29 |  
 30 |  
 31 |  
 32 |  
 33 | int main()
 34 | {
 35 |     ios_base::sync_with_stdio(false);
 36 |     cin.tie(NULL);
 37 |     cin>>n>>m;
 38 |     ll stx,sty;
 39 |     
 40 |     for(ll i=0;i<n;i++){
 41 |         cin>>grid[i];
 42 |         for(ll j=0;j<grid[i].length();j++){
 43 |             if(grid[i][j]=='A'){
 44 |                 stx=i;
 45 |                 sty=j;
 46 |             }
 47 |         }
 48 |     }
 49 |  
 50 |  
 51 |     queue<pair<ll,ll>> q;
 52 |  
 53 |     q.push({stx,sty});
 54 |     bool flag=false;
 55 |     ll X,Y;
 56 |     while(!q.empty()){
 57 |         pair<ll,ll> pr=q.front();
 58 |         q.pop();
 59 |  
 60 |         for(ll i=0;i<4;i++){
 61 |             ll x=pr.first+xrr[i];
 62 |             ll y=pr.second+yrr[i];
 63 |  
 64 |             if(issafe(x,y)){
 65 |                 q.push({x,y});
 66 |                 par[x][y]={pr.first,pr.second};
 67 |                 if(grid[x][y]=='B'){
 68 |                     X=x,Y=y;
 69 |                     flag=true;
 70 |                     break;
 71 |                 }
 72 |                 grid[x][y]='#';
 73 |             }
 74 |  
 75 |         }
 76 |  
 77 |         if(flag){
 78 |             break;
 79 |         }
 80 |     }
 81 |  
 82 |     if(!flag){
 83 |         cout<<"NO"<<endl;
 84 |         return 0;
 85 |     }
 86 |  
 87 |     cout<<"YES"<<endl;
 88 |  
 89 |     string s="";
 90 |     while(grid[X][Y]!='A'){
 91 |         pair<ll,ll> pr=par[X][Y];
 92 |  
 93 |         ll xr=X-pr.first;
 94 |         ll yr=Y-pr.second;
 95 |         // cout<<xr<<" "<<yr<<endl;
 96 |  
 97 |         for(ll i=0;i<4;i++){
 98 |             if(xr==xrr[i] && yr==yrr[i]){
 99 |                 s+=ch[i];
100 |                 break;
101 |             }
102 |         }
103 |  
104 |         X=pr.first;
105 |         Y=pr.second;
106 |  
107 |  
108 |     }
109 |     reverse(s.begin(),s.end());
110 |     cout<<s.length()<<endl;
111 |     cout<<s<<endl;
112 |  
113 |  
114 |  
115 |  
116 |  
117 |  
118 |  
119 |     return 0;
120 | }
121 | 


--------------------------------------------------------------------------------
/cses graph/1195 Flight discount.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | ll n, m;
15 | 
16 | void dijkastra(vector<vector<pair<ll, ll>>> graph, vector<ll> &shortest,ll nd)
17 | {
18 |     priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> pq;
19 |     pq.push({0, nd});
20 | 
21 |     while (!pq.empty())
22 |     {
23 |         pair<ll, ll> p = pq.top();
24 |         pq.pop();
25 |         if (shortest[p.second] == -1)
26 |         {
27 |             shortest[p.second] = p.first;
28 |             for (auto i : graph[p.second])
29 |             {
30 |                 if (shortest[i.first] == -1)
31 |                 {
32 |                     pq.push({i.second + p.first, i.first});
33 |                 }
34 |             }
35 |         }
36 |     }
37 | }
38 | 
39 | int main()
40 | {
41 |     ios_base::sync_with_stdio(false);
42 |     cin.tie(NULL);
43 |     cin >> n >> m;
44 | 
45 |     vector<vector<pair<ll, ll>>> graphf(n+1);
46 |     vector<vector<pair<ll, ll>>> graphr(n+1);
47 |     vector<ll> shortestf(n+1, -1);
48 |     vector<ll> shortestr(n+1, -1);
49 |     vector<pair<pair<ll,ll>,ll>> edges;
50 |     for (ll i = 0; i < m; i++)
51 |     {
52 |         ll u, v, c;
53 |         cin >> u >> v >> c;
54 |         graphf[u].push_back({v, c});
55 |         graphr[v].push_back({u, c});
56 |         edges.push_back({{u,v},c});
57 |     }
58 |     dijkastra(graphf,shortestf,1);
59 |     dijkastra(graphr,shortestr,n);
60 | 
61 |     // for(ll i=1;i<=n;i++){
62 |     //     cout<<shortestf[i]<<" ";
63 |     // }
64 |     // cout<<endl;
65 | 
66 |     
67 |     // for(ll i=1;i<=n;i++){
68 |     //     cout<<shortestr[i]<<" ";
69 |     // }
70 |     // cout<<endl;
71 |     ll ans=shortestf[n];
72 |     for(auto i:edges){
73 |         if(shortestf[i.first.first]!=-1 && shortestr[i.first.second]!=-1){
74 |         ll val=shortestf[i.first.first]+shortestr[i.first.second]+(i.second)/2;
75 |         
76 |         ans=min(ans,val);}
77 |     }
78 |     cout<<ans<<endl;
79 | 
80 |     return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/cses graph/1196 FlightRoutes.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll long long
13 | 
14 | ll n, m, k;
15 | 
16 | vector<pair<ll, ll>> graph[100005];
17 | vector<ll> shortest(100005, -1);
18 | 
19 | int main()
20 | {
21 |     ios_base::sync_with_stdio(false);
22 |     cin.tie(NULL);
23 |     cin >> n >> m >> k;
24 |     for (ll i = 0; i < m; i++)
25 |     {
26 |         ll u, v, c;
27 |         cin >> u >> v >> c;
28 |         graph[u].push_back({v, c});
29 |     }
30 |     priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> pq;
31 |     pq.push({0, 1});
32 |     vector<ll> ans;
33 |     vector<ll> cnt(n+1,0);
34 |     while (!pq.empty())
35 |     {
36 |         pair<ll, ll> p = pq.top();
37 |         pq.pop();
38 |         cnt[p.second]++;
39 |         if (p.second == n)
40 |         {
41 |             ans.push_back(p.first);
42 |         }
43 |         if(cnt[n]==k){
44 |             // cout<<"YES"<<endl;
45 |             break;
46 |         }
47 | 
48 |         if(cnt[p.second]<=k){
49 |         for (auto i : graph[p.second])
50 |         {
51 |                 pq.push({i.second + p.first, i.first});
52 |             
53 |         }
54 |         }
55 |     }
56 |     for(auto i:ans){
57 |         cout<<i<<" ";
58 |     }
59 |     cout << endl;
60 | 
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/cses graph/1197 CycleFinding.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 |  
14 | ll n, m;
15 |  
16 | struct edge{
17 |     ll u,v,c;
18 | };
19 |  
20 |  
21 |  
22 |  
23 | int main()
24 | {
25 |     ios_base::sync_with_stdio(false);
26 |     cin.tie(NULL);
27 |     cin >> n >> m;
28 |     vector<edge> edges;
29 |     for(ll i=0;i<m;i++){
30 |         ll u,v,c;
31 |         cin>>u>>v>>c;
32 |         edges.push_back({u,v,c});
33 |     }
34 |     vector<ll> d(n+1);
35 |     vector<ll> par(n+1,-1);
36 |     ll x=-1;
37 |     for(ll i=0;i<n;i++){
38 |         x=-1;
39 |         for(auto j:edges){
40 |             if(d[j.v]>d[j.u]+j.c){
41 |                 d[j.v]=d[j.u]+j.c;
42 |                 x=j.v;
43 |                 par[j.v]=j.u;
44 |             }
45 |         }
46 |  
47 |     }
48 |  
49 |     if(x==-1){
50 |         cout<<"NO"<<endl;
51 |         return 0;
52 |     }
53 |     cout<<"YES"<<endl;
54 |     vector<ll> vec;
55 |  
56 |     for(ll i=0;i<n;i++){
57 |         x=par[x];
58 |     }
59 |  
60 |     ll st=x;
61 |     
62 |     while(1){
63 |         vec.push_back(x);
64 |         x=par[x];
65 |         if(x==st){
66 |             vec.push_back(x);
67 |             break;
68 |         }
69 |         
70 |     }
71 |  
72 |  
73 |     reverse(vec.begin(),vec.end());
74 |     for(auto i:vec){
75 |         cout<<i<<" ";
76 |     }
77 |     cout<<endl;
78 |  
79 |  
80 |  
81 |  
82 |  
83 |     
84 |     return 0;
85 | }
86 | 


--------------------------------------------------------------------------------
/cses graph/1202 Investigation.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 | ll n, m;
15 |  
16 | vector<pair<ll,ll>> graph[100005];
17 | vector<bool> visited(100005,false);
18 | bool flag=false;
19 | vector<ll> dp(100005,-1);
20 | vector<ll> dp1(100005,-1);
21 | vector<ll> dp2(100005,INT_MAX);
22 | vector<ll> dp3(100005,0);
23 |  
24 |  
25 |  
26 | int main()
27 | {
28 |     ios_base::sync_with_stdio(false);
29 |     cin.tie(NULL);
30 |     cin >> n >> m;
31 |     for(ll i=0;i<m;i++){
32 |         ll u,v,c;
33 |         cin>>u>>v>>c;
34 |         graph[u].push_back({v,c});
35 |     }
36 |     priority_queue<pair<ll,ll>,vector<pair<ll,ll>>,greater<pair<ll,ll>>> pq;
37 |     pq.push({0,1});
38 |     dp[1]=0;
39 |     dp1[1]=1;
40 |     dp2[1]=0;
41 |     dp3[1]=0;
42 |     while(!pq.empty()){
43 |         pair<ll,ll> pr=pq.top();
44 |         pq.pop();
45 |         if(visited[pr.second]){
46 |             continue;
47 |         }
48 |         visited[pr.second]=true;
49 |         for(auto i:graph[pr.second]){
50 |             if(visited[i.first]){
51 |                 continue;
52 |             }
53 |             if(dp[i.first]==-1 || dp[i.first]>dp[pr.second]+i.second){
54 |                 dp[i.first]=dp[pr.second]+i.second;
55 |                 dp1[i.first]=dp1[pr.second];
56 |                 dp2[i.first]=dp2[pr.second]+1;
57 |                 dp3[i.first]=dp3[pr.second]+1;
58 |                 pq.push({dp[i.first],i.first});
59 |             }else if(dp[i.first]==(dp[pr.second]+i.second)){
60 |                 dp1[i.first]=dp1[i.first]%mod + dp1[pr.second]%mod;
61 |                 dp1[i.first]%=mod;
62 |                 dp2[i.first]=min(dp2[i.first],dp2[pr.second]+1);
63 |                 dp3[i.first]=max(dp3[i.first],dp3[pr.second]+1);
64 |                 // pq.push({dp[i.first],i.first});
65 | 
66 |             }
67 | 
68 |         }
69 | 
70 |     }
71 | 
72 |     // for(ll i=1;i<=n;i++){
73 |         // cout<<dp[i]<<" ";
74 |     // }
75 |     cout<<endl;
76 |     cout<<dp[n]<<" "<<dp1[n]<<" "<<dp2[n]<<" "<<dp3[n]<<endl;
77 |    
78 |     
79 |     return 0;
80 | }
81 | 


--------------------------------------------------------------------------------
/cses graph/1666 Building Roads.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include<bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 |  
14 | ll n,m;
15 |  
16 | vector<ll> graph[100005];
17 |  
18 | vector<bool> visited(100005,false);
19 |  
20 |  
21 | void dfs(ll u){
22 |     visited[u]=true;
23 |     for(auto i:graph[u]){
24 |         if(!visited[i]){
25 |             dfs(i);
26 |         }
27 |     }
28 | }
29 |  
30 |  
31 | int main(){
32 |     cin>>n>>m;
33 |  
34 |     for(ll i=0;i<m;i++){
35 |         ll u,v;
36 |         cin>>u>>v;
37 |         graph[u].push_back(v);
38 |         graph[v].push_back(u);
39 |     }
40 |     vector<ll> vec;
41 |     for(ll i=1;i<=n;i++){
42 |         if(!visited[i]){
43 |             vec.push_back(i);
44 |             dfs(i);
45 |             
46 |         }
47 |     }
48 |  
49 |     cout<<vec.size()-1<<endl;
50 |     for(ll i=1;i<(ll)vec.size();i++){
51 |         cout<<vec[i-1]<<" "<<vec[i]<<endl;
52 |     }
53 |  
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/cses graph/1667 Message Route.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 |  
14 | ll n, m;
15 |  
16 | vector<ll> graph[100005];
17 |  
18 | vector<bool> visited(100005, false);
19 |  
20 | int main()
21 | {
22 |     cin >> n >> m;
23 |  
24 |     for (ll i = 0; i < m; i++)
25 |     {
26 |         ll u, v;
27 |         cin >> u >> v;
28 |         graph[u].push_back(v);
29 |         graph[v].push_back(u);
30 |     }
31 |  
32 |     queue<ll> q;
33 |     q.push(1);
34 |     vector<ll> par(n + 1, -1);
35 |  
36 |     while (!q.empty())
37 |     {
38 |         ll u = q.front();
39 |  
40 |         q.pop();
41 |         if(u==n){
42 |             break;
43 |         }
44 |         
45 |         visited[u] = true;
46 |  
47 |         for (auto i : graph[u])
48 |         {
49 |             if (!visited[i])
50 |             {
51 |                 q.push(i);
52 |                 visited[i]=true;
53 |                 par[i] = u;
54 |             }
55 |         }
56 |     }
57 |  
58 |     if(par[n]==-1){
59 |         cout << "IMPOSSIBLE" << endl;
60 |         return 0;
61 |     }
62 |  
63 |     ll val=n;
64 |     vector<ll> vec;
65 |     while(val!=1){
66 |         vec.push_back(val);
67 |         val=par[val];
68 |     }
69 |     vec.push_back(1);
70 |     reverse(vec.begin(),vec.end());
71 |     cout<<vec.size()<<endl;
72 |  
73 |     for(auto i:vec){
74 |         cout<<i<<" ";
75 |     
76 |     }
77 |     
78 |  
79 |     
80 |  
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/cses graph/1669 Round Trip.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // problem is asking about finding cycle with length>=3
10 | 
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 | 
14 | #define ll long long
15 | 
16 | ll n,m;
17 | 
18 | vector<ll> graph[100005];
19 | vector<bool> visited(100005,false);
20 | vector<ll> parent(100005,-1);
21 | vector<ll> vec;
22 | 
23 | 
24 | void dfs(ll u,ll pr){
25 | 
26 |     visited[u]=true;
27 |     parent[u]=pr;
28 |     if(vec.size()>=4){
29 |         
30 |         return ;
31 |     }
32 | 
33 |     for(auto i: graph[u]){
34 |         if(visited[i] && vec.size()<=3){
35 |             ll nd=u;
36 |             vec.clear();
37 |             vec.push_back(i);
38 | 
39 | 
40 |             while(nd!=i)
41 |             {
42 |                 vec.push_back(nd);
43 |                 nd=parent[nd];
44 |             }
45 |             vec.push_back(i);
46 | 
47 |             
48 |             reverse(vec.begin(),vec.end());
49 |         }else{
50 |             dfs(i,u);
51 |         }
52 |     }
53 | 
54 | 
55 | }
56 | 
57 | 
58 | int main()
59 | {
60 |     ios_base::sync_with_stdio(false);
61 |     cin.tie(NULL);
62 |     cin>>n>>m;
63 | 
64 |     for(ll i=0;i<m;i++){
65 |         ll u,v;
66 |         cin>>u>>v;
67 |         graph[u].push_back(v);
68 |         graph[v].push_back(u);
69 |     }
70 | 
71 |     for(ll i=1;i<=n;i++){
72 |         if(!visited[i]){
73 |             dfs(i,-1);
74 |             // cout<<"NO"<<endl;
75 |             if(vec.size()>=4){
76 |                 cout<<vec.size()<<endl;
77 |                 for(auto j:vec){
78 |                     cout<<j<<" ";
79 |                 }
80 |                 cout<<endl;
81 |                 return 0;
82 |             }
83 |         }
84 |     }
85 |     cout<<"IMPOSSIBLE"<<endl;
86 | 
87 | 
88 | 
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/cses graph/1671 Shortest Routes I.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 | 
 9 | // just standard dijkastra algorithms
10 |  
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 |  
14 | #define ll long long
15 |  
16 | ll n, m;
17 | 
18 | vector<pair<ll,ll>> graph[100005];
19 | vector<ll> shortest(100005,-1);
20 |  
21 | int main()
22 | {
23 |     ios_base::sync_with_stdio(false);
24 |     cin.tie(NULL);
25 |     cin >> n >> m;
26 |     for (ll i = 0; i < m; i++)
27 |     {
28 |         ll u,v,c;
29 |         cin>>u>>v>>c;
30 |         graph[u].push_back({v,c});
31 | 
32 |     }
33 |     priority_queue<pair<ll,ll>,vector<pair<ll,ll>>,greater<pair<ll,ll>>> pq;
34 |     pq.push({0,1});
35 |  
36 |     while (!pq.empty())
37 |     {
38 |         pair<ll,ll> p = pq.top();
39 |         pq.pop();
40 |         if(shortest[p.second]==-1){
41 |             shortest[p.second]=p.first;
42 |             for(auto i:graph[p.second]){
43 |                 if(shortest[i.first]==-1){
44 |                     pq.push({i.second+p.first,i.first});
45 |                 }
46 |             }
47 |         }
48 |         
49 |     }
50 | 
51 |     for(ll i=1;i<=n;i++){
52 |         cout<<shortest[i]<<" ";
53 |     }
54 |     cout<<endl;
55 |  
56 |     return 0;
57 | }
58 | 
59 | 
60 | 


--------------------------------------------------------------------------------
/cses graph/1672 Shortest Routes II.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 | 
 9 | /*
10 | floyd-warshall algorithm:
11 | 
12 | https://cp-algorithms.com/graph/all-pair-shortest-path-floyd-warshall.html
13 | */
14 |  
15 | #include <bits/stdc++.h>
16 | using namespace std;
17 |  
18 | #define ll long long
19 | #define INF 1e15
20 |  
21 | ll n, m,q;
22 |  
23 | vector<vector<ll>> dp(1001, vector<ll>(1001, INF));
24 |  
25 | int main()
26 | {
27 |     ios_base::sync_with_stdio(false);
28 |     cin.tie(NULL);
29 |     cin >> n >> m>>q;
30 |     for (ll i = 0; i < m; i++)
31 |     {
32 |         ll u, v, c;
33 |         cin >> u >> v >> c;
34 |         dp[u][v]=min(dp[u][v],c);
35 |         dp[v][u]=min(dp[v][u],c);
36 |  
37 |     }
38 |  
39 |  
40 |     for(ll i=1;i<=n;i++){
41 |         dp[i][i]=0;
42 |     }
43 |  
44 |     for(ll i=1;i<=n;i++){
45 |         for(ll j=1;j<=n;j++){
46 |             for(ll k=1;k<=n;k++){
47 |                 dp[j][k]=min(dp[j][k],dp[j][i]+dp[i][k]);
48 |                 
49 |             }
50 |         }
51 |     }
52 |  
53 |     while(q--){
54 |         ll l,r;
55 |         cin>>l>>r;
56 |         if(dp[l][r]<INF){
57 |         cout<<dp[l][r]<<endl;
58 |         }else{
59 |             cout<<"-1"<<endl;
60 |         }
61 |     }
62 |     return 0;
63 | }
64 | 
65 | 


--------------------------------------------------------------------------------
/cses graph/1673 High_score.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define INF 1e15
14 | ll n,m;
15 |  
16 | struct ed
17 | {
18 |     ll u,v,c;
19 | };
20 |  
21 | vector<ll> graphf[2505];
22 | vector<ll> graphr[2505];
23 | vector<bool> vis1(2505,false);
24 | vector<bool> visn(2505,false);
25 |  
26 | void dfs(ll v){
27 |     vis1[v]=true;
28 |     for(auto u:graphf[v]){
29 |         if(!vis1[u]){
30 |             dfs(u);
31 |         }
32 |     }
33 | }
34 | void dfs1(ll v){
35 |     visn[v]=true;
36 |     for(auto u:graphr[v]){
37 |         if(!visn[u]){
38 |             dfs1(u);
39 |         }
40 |     }
41 | }
42 |  
43 | int main()
44 | {
45 |     ios_base::sync_with_stdio(false);
46 |     cin.tie(NULL);
47 |     cin >> n >> m;
48 |  
49 |     vector<ed> edges;
50 |     for (ll i = 0; i < m; i++)
51 |     {
52 |         ll u, v, c;
53 |         cin >> u >> v >> c;
54 |         graphf[u].push_back(v);
55 |         graphr[v].push_back(u);
56 |         edges.push_back({u,v,c});
57 |     }
58 |     // cout<<"YES"<<endl;
59 |  
60 |     dfs(1);
61 |     dfs1(n);
62 |     vector<ll> d(n+1,INT_MIN);
63 |     d[1]=0;
64 |     ll ans=-1;
65 |     bool flag=false;
66 |     for(ll j=0;j<n;j++){
67 |         flag=false;
68 |         for(ll i=0;i<m;i++){
69 |             ed nd=edges[i];
70 |             if(d[nd.u]>INT_MIN){
71 |                 if(vis1[nd.v] && visn[nd.v] && d[nd.v]< d[nd.u]+nd.c){
72 |                     d[nd.v]= d[nd.u]+nd.c;
73 |                     flag=true;
74 |                 }
75 |             }
76 |         }
77 |         if(j==n-1){
78 |             ans=d[n];
79 |         }
80 |  
81 |     }
82 |     if(flag || d[n]==INT_MIN){
83 |         cout<<"-1"<<endl;
84 |         return 0;
85 |     }
86 |     cout<<d[n]<<endl;
87 |  
88 |  
89 |  
90 |     return 0;
91 | }
92 | 


--------------------------------------------------------------------------------
/cses graph/1675-RoadConstruction.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | 
10 | /*
11 | dijkastra.
12 | 
13 | */
14 | 
15 | 
16 | #include <bits/stdc++.h>
17 | using namespace std;
18 | 
19 | #define ll long long
20 | #define mod 1000000007
21 | ll n,m;
22 | 
23 | 
24 | vector<pair<ll,ll>> graph[200005];
25 | vector<bool> visited(200005, false);
26 | 
27 | 
28 | int main()
29 | {
30 |     ios_base::sync_with_stdio(false);
31 |     cin.tie(NULL);
32 | 
33 |     // ll n;
34 |     cin >> n>>m;
35 | 
36 |     for (ll i = 0; i <m; i++)
37 |     {
38 |         ll u, v,c;
39 |         cin >> u >> v>>c;
40 |         graph[u].push_back({v,c});
41 |         graph[v].push_back({u,c});
42 |         
43 |     }   
44 |     priority_queue<pair<ll,ll>,vector<pair<ll,ll>>,greater<pair<ll,ll>>> pq;
45 |     pq.push({0,1});
46 |     ll ans=0;
47 |     while(!pq.empty()){
48 |         pair<ll,ll> pr=pq.top();
49 |         pq.pop();
50 | 
51 |         if(visited[pr.second]){
52 |             continue;
53 |         }
54 |         visited[pr.second]=true;
55 |         ans+=pr.first;
56 | 
57 |         for(auto i:graph[pr.second]){
58 |             if(!visited[i.first]){
59 |                 pq.push({i.second,i.first});
60 |             }
61 |         }
62 |     }
63 |     for(ll i=1;i<=n;i++){
64 |         if(!visited[i]){
65 |             cout<<"IMPOSSIBLE"<<endl;
66 |             return 0;
67 |         }
68 |     }
69 |     cout<<ans<<endl;
70 | 
71 | 
72 | 
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/cses graph/1676-Road Construction.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | 
10 | // DSU
11 | 
12 | 
13 | #include <bits/stdc++.h>
14 | using namespace std;
15 | 
16 | #define ll long long
17 | #define mod 1000000007
18 | ll n,m;
19 | 
20 | vector<ll> fn(200005,0);
21 | vector<ll> cnt(2000005,0);
22 | 
23 | vector<ll> vec[200005];
24 | 
25 | 
26 | ll mx;
27 | ll sz=1;
28 | 
29 | 
30 | void unite(ll u,ll v){
31 |     // cout<<u<<" st"<<v<<endl;
32 |     u=fn[u];
33 |     v=fn[v];
34 |     // cout<<u<<" "<<v<<endl;
35 | 
36 |     if(u!=v){
37 |     if(cnt[u]!=0 && cnt[v]!=0){
38 |         mx--;
39 |     }
40 |     if(cnt[u]<=cnt[v]){
41 |         cnt[v]+=cnt[u];
42 |         cnt[u]=0;
43 |         sz=max(sz,cnt[v]);
44 | 
45 |         for(auto i:vec[u]){
46 |             fn[i]=v;
47 |             vec[v].push_back(i);
48 |         }
49 |     }else{
50 |         cnt[u]+=cnt[v];
51 |         cnt[v]=0;
52 |         sz=max(sz,cnt[u]);
53 | 
54 |         for(auto i:vec[v]){
55 |             fn[i]=u;
56 |             vec[u].push_back(i);
57 |         }
58 |     }
59 |     }
60 | }
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | int main()
68 | {
69 |     ios_base::sync_with_stdio(false);
70 |     cin.tie(NULL);
71 | 
72 |     // ll n;
73 |     cin >> n>>m;
74 | 
75 |     for(ll i=1;i<=n;i++){
76 |         fn[i]=i;
77 |         cnt[i]=1;
78 |         vec[i].push_back(i);
79 |     }
80 |     // cout<<mx<<endl;
81 |     mx=n;
82 | 
83 |     for (ll i = 0; i <m; i++)
84 |     {
85 |         ll u,v;
86 |         cin>>u>>v;
87 |         // mx--;
88 |         unite(u,v);
89 |         cout<<mx<<" "<<sz<<endl;
90 | 
91 |     }    
92 | 
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/cses graph/1679 CouseShedule.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 | 
12 | #define ll int
13 | 
14 | ll n, m;
15 | 
16 | vector<ll> graph[100005];
17 | vector<bool> visited(100005,false);
18 | bool flag=false;
19 | vector<ll> order;
20 | vector<ll> ans;
21 | vector<ll> visited1(100005,0);
22 | ll x=-1;
23 | void dfs1(ll v){
24 |     if(flag){
25 |  
26 |         return ;
27 |     }
28 |     visited1[v]=1;
29 |     // cout<<v<<" "<<endl;
30 |     for(auto u:graph[v]){
31 |         if(visited1[u]==1){
32 |             flag=true;
33 |             return ;
34 |         }
35 |         if(visited1[u]==0){
36 |             dfs1(u);
37 |         }
38 |         
39 |     }
40 |     visited1[v]=2;
41 | }
42 | void dfs(ll v){
43 |     
44 |     visited[v]=true;
45 |     // cout<<v<<" ";
46 |     for(auto u:graph[v]){
47 |        
48 |         if(!visited[u]){
49 |             dfs(u);
50 |         }
51 |     }
52 |     order.push_back(v);
53 | }
54 | 
55 | 
56 | int main()
57 | {
58 |     ios_base::sync_with_stdio(false);
59 |     cin.tie(NULL);
60 |     cin >> n >> m;
61 |     for(ll i=0;i<m;i++){
62 |         ll u,v;
63 |         cin>>u>>v;
64 |         graph[u].push_back(v);
65 |     }
66 | 
67 |     for(ll i=1;i<=n;i++){
68 |         if(visited1[i]==0){
69 |             dfs1(i);
70 |         }
71 |         if(flag){
72 |             break;
73 |         }
74 |     }
75 |     if(flag){
76 |         cout<<"IMPOSSIBLE"<<endl;
77 |         return 0;
78 |     }
79 | 
80 |     for(ll i=1;i<=n;i++){
81 |         if(!visited[i]){
82 |             dfs(i);
83 |         }
84 |     }
85 |     reverse(order.begin(),order.end());
86 |     visited.assign(n+1,false);
87 | 
88 |     for(auto i:order){
89 |         cout<<i<<" ";
90 |     }
91 |     cout<<endl;
92 |     
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/cses graph/1680 longestFlightRoute(dijkastra).cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | /*
10 | This code is giving tle but this is also a method to solve this problem
11 | basically assign every node -1 weight and apply dijkastra.
12 | */
13 | 
14 | #include <bits/stdc++.h>
15 | using namespace std;
16 | 
17 | #define endl "\n"
18 | 
19 | #define ll int
20 | 
21 | 
22 | int main()
23 | {
24 |     ios_base::sync_with_stdio(false);
25 |     cin.tie(NULL);
26 |     ll n, m;
27 |     cin >> n >> m;
28 |     vector<ll> graph[n + 1];
29 |     vector<ll> par(n + 1, -1);
30 |     vector<ll> d(n + 1, 0);
31 |     for (ll i = 0; i < m; i++)
32 |     {
33 |         ll u, v;
34 |         cin >> u >> v;
35 |         graph[u].push_back(v);
36 |     }
37 |     d[1] = 0;
38 |     par[1]=-1;
39 |     priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> pq;
40 |     pq.push({0, 1});
41 |     while (!pq.empty())
42 |     {
43 |         pair<ll, ll> pr = pq.top();
44 |         pq.pop();
45 |         if (d[pr.second] < pr.first)
46 |         {
47 |             continue;
48 |         }
49 |         for (auto i : graph[pr.second])
50 |         {
51 |             if (d[i] > d[pr.second] - 1)
52 |             {
53 |                 d[i] = d[pr.second] - 1;
54 |                 pq.push({d[i], i});
55 |                 par[i] = pr.second;
56 |             }
57 |         }
58 |     }
59 | 
60 |     if (d[n] == 0)
61 |     {
62 |         cout << "IMPOSSIBLE" << endl;
63 |         return 0;
64 |     }
65 |     cout << (-1 * d[n] + 1) << endl;
66 |     vector<ll> ans;
67 |     ll nd = n;
68 |     while (nd != -1)
69 |     {
70 |         ans.push_back(nd);
71 |         nd = par[nd];
72 |     }
73 |     reverse(ans.begin(), ans.end());
74 |     for (auto i : ans)
75 |     {
76 |         cout << i << " ";
77 |     }
78 |     cout << endl;
79 | 
80 |     return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/cses graph/1680 longestFlightRoute(optimised).cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll int
13 |  
14 | ll n, m;
15 |  
16 | vector<ll> graph[100005];
17 | vector<bool> visited(100005,false);
18 | bool flag=false;
19 | vector<ll> par(100005,-1);
20 | vector<ll> d(100005,-1);
21 |  
22 |  
23 | void dfs(ll v){
24 |     
25 |     if(v==n){
26 |         flag=true;
27 |         d[v]=0;
28 |         return ;
29 |     }
30 |  
31 |     
32 |     visited[v]=true;
33 |     for(auto u:graph[v]){
34 |       
35 |  
36 |         
37 |         if(!visited[u]){
38 |             dfs(u);
39 |         }
40 |         if(d[u]==-1){
41 |             continue;
42 |         }
43 |         if(d[v]< d[u]+1){
44 |             d[v]=d[u]+1;
45 |             par[v]=u;
46 |         }
47 |  
48 |         
49 |  
50 |  
51 |     }
52 |  
53 |  
54 | }
55 |  
56 |  
57 |  
58 |  
59 | int main()
60 | {
61 |     ios_base::sync_with_stdio(false);
62 |     cin.tie(NULL);
63 |     cin >> n >> m;
64 |     for(ll i=0;i<m;i++){
65 |         ll u,v;
66 |         cin>>u>>v;
67 |         graph[u].push_back(v);
68 |     }
69 |     d[1]=0;
70 |     
71 |  
72 |     dfs(1);
73 |     // cout<<"-1"<<endl;
74 |  
75 |     if(!flag){
76 |         cout<<"IMPOSSIBLE"<<endl;
77 |         return 0;
78 |     }
79 |  
80 |     vector<ll> ans;
81 |     ll nd=1;
82 |     while(nd!=-1){
83 |         ans.push_back(nd);
84 |         nd=par[nd];
85 |     }
86 |     // reverse(ans.begin(),ans.end());
87 |     cout<<ans.size()<<endl;
88 |     for(auto i:ans){
89 |         cout<<i<<" ";
90 |     }
91 |     cout<<endl;
92 |  
93 |    
94 |     
95 |     return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/cses graph/1681 GameRoutes.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 | ll n, m;
15 |  
16 | vector<ll> graph[100005];
17 | vector<bool> visited(100005,false);
18 | bool flag=false;
19 | vector<ll> par(100005,-1);
20 | vector<ll> d(100005,0);
21 |  
22 | ll ans=0;
23 | void dfs(ll v){
24 |     
25 |     if(v==n){
26 |         flag=true;
27 |         d[v]=1;
28 |         return ;
29 |     }
30 |  
31 |     
32 |     visited[v]=true;
33 |     ll ans=0;
34 |     for(auto u:graph[v]){
35 |         if(!visited[u]){
36 |             dfs(u);
37 |         }
38 |         
39 |         ans=ans%mod + (d[u]%mod);
40 |         ans%=mod;
41 |  
42 |     }
43 |     d[v]=ans;
44 | }
45 | int main()
46 | {
47 |     ios_base::sync_with_stdio(false);
48 |     cin.tie(NULL);
49 |     cin >> n >> m;
50 |     for(ll i=0;i<m;i++){
51 |         ll u,v;
52 |         cin>>u>>v;
53 |         graph[u].push_back(v);
54 |     }
55 |     d[1]=0;
56 |     
57 |  
58 |     dfs(1);
59 |     // cout<<"-1"<<endl;
60 |     cout<<d[1]<<endl;
61 |  
62 |    
63 |     
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/cses graph/1682-FlightRouteCheck.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | 
10 | 
11 | /*
12 | kosaraju algorithm.
13 | 
14 | step:-
15 | 1 perform topo sort.
16 | 2 reverse all link of directed graph.
17 | 3. run dfs over graph from topo sort first node.
18 | and the node which is not visited will not connect with first node of topo sort.
19 | */
20 | 
21 | 
22 | #include <bits/stdc++.h>
23 | using namespace std;
24 | 
25 | #define ll long long
26 | #define mod 1000000007
27 | ll n,m;
28 | 
29 | vector<bool> visited(200005,false);
30 | vector<ll> graph[200005];
31 | vector<ll> order;
32 | vector<ll> graphr[200005];
33 | 
34 | 
35 | 
36 | void topo(ll v){
37 |     visited[v]=true;
38 |     for(auto u:graph[v]){
39 |         if(!visited[u]){
40 |             topo(u);
41 |         }
42 |     }
43 | 
44 |     order.push_back(v);
45 | }
46 | 
47 | void dfs(ll v){
48 |     visited[v]=true;
49 |     for(auto u:graphr[v]){
50 |         if(!visited[u]){
51 |             dfs(u);
52 |         }
53 |     }
54 | 
55 | }
56 | 
57 | 
58 | 
59 | int main()
60 | {
61 |     ios_base::sync_with_stdio(false);
62 |     cin.tie(NULL);
63 | 
64 |     // ll n;
65 |     cin >> n>>m;
66 | 
67 |     for (ll i = 0; i <m; i++)
68 |     {
69 |         ll u,v;
70 |         cin>>u>>v;
71 |         graph[u].push_back(v);
72 |         graphr[v].push_back(u);
73 |        
74 |     }
75 |     topo(1);
76 |     // cout<<"YES"<<endl;
77 |     visited.assign(n+1,false);
78 |     
79 |     ll nd=order[n-1];
80 |     // cout<<nd<<endl;
81 | 
82 |     dfs(nd);
83 |     for(ll i=1;i<=n;i++){
84 |         if(!visited[i]){
85 |             cout<<"NO"<<endl;
86 |             cout<<i<<" "<<nd<<endl;
87 |             return 0;
88 |         }
89 |     }
90 |     cout<<"YES"<<endl;
91 | 
92 |     
93 | 
94 |     return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/cses graph/1683-planets And Kingdoms.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 | 
 3 | // manitianajay45
 4 | 
 5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
 6 | 
 7 | // sab moh maya hai....
 8 | 
 9 | // kosaraju algo
10 | 
11 | 
12 | 
13 | #include <bits/stdc++.h>
14 | using namespace std;
15 | 
16 | #define ll long long
17 | #define mod 1000000007
18 | ll n,m;
19 | 
20 | vector<bool> visited(200005,false);
21 | vector<ll> graph[200005];
22 | vector<ll> order;
23 | vector<ll> graphr[200005];
24 | ll an=0;
25 | vector<ll> ans(200005,0);
26 | 
27 | 
28 | void topo(ll v){
29 |     visited[v]=true;
30 |     for(auto u:graph[v]){
31 |         if(!visited[u]){
32 |             topo(u);
33 |         }
34 |     }
35 |     order.push_back(v);
36 | }
37 | 
38 | void dfs(ll v){
39 |     visited[v]=true;
40 |     ans[v]=an;
41 |     for(auto u:graphr[v]){
42 |         if(!visited[u]){
43 |             dfs(u);
44 |         }
45 |     }
46 | 
47 | }
48 | 
49 | 
50 | 
51 | int main()
52 | {
53 |     ios_base::sync_with_stdio(false);
54 |     cin.tie(NULL);
55 | 
56 |     // ll n;
57 |     cin >> n>>m;
58 | 
59 |     for (ll i = 0; i <m; i++)
60 |     {
61 |         ll u,v;
62 |         cin>>u>>v;
63 |         graph[u].push_back(v);
64 |         graphr[v].push_back(u);
65 |        
66 |     }
67 |     for(ll i=1;i<=n;i++){
68 |         if(!visited[i]){
69 |             topo(i);
70 |         }
71 |     }
72 |     // cout<<"YES"<<endl;
73 |     visited.assign(n+1,false);
74 |     reverse(order.begin(),order.end());
75 |     // for(auto i:order){
76 |         // cout<<i<<" ";
77 |     // }
78 |     cout<<endl;
79 |     for(auto i:order){
80 |         // cout<<i<<" ";
81 |         if(!visited[i]){
82 |             an++;
83 |             dfs(i);
84 |         }
85 |     }
86 |     // cout<<endl;
87 |     // cout<<"YES"<<endl;
88 |     cout<<an<<endl;
89 |     for(ll i=1;i<=n;i++){
90 |         cout<<ans[i]<<" ";
91 |     }
92 |     cout<<endl;
93 | 
94 |     
95 | 
96 |     return 0;
97 | }
98 | 


--------------------------------------------------------------------------------
/cses graph/1684-Giant Pizza.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | /* 
 10 |   2SAT problem
 11 |   https://cses.fi/book/book.pdf
 12 |   page no - 160-162
 13 | /*
 14 | 
 15 | 
 16 | 
 17 | #include <bits/stdc++.h>
 18 | using namespace std;
 19 | 
 20 | #define ll long long
 21 | #define mod 1000000007
 22 | ll n,m;
 23 | 
 24 | bool visited[200005][2];
 25 | string ans(200005,'*');
 26 | vector<pair<ll,ll>> graph[200005][2];
 27 | vector<pair<ll,ll>> order;
 28 | vector<pair<ll,ll>> graphr[200005][2];
 29 | ll vis[200005][2];
 30 | ll an=0;
 31 | 
 32 | 
 33 | void topo(ll v,ll tp){
 34 |     visited[v][tp]=true;
 35 |     for(auto u:graph[v][tp]){
 36 |         if(!visited[u.first][u.second]){
 37 |             topo(u.first,u.second);
 38 |         }
 39 |     }
 40 |     order.push_back({v,tp});
 41 | }
 42 | bool flag=true;
 43 | 
 44 | void dfs(ll v,ll tp){
 45 | 
 46 | 
 47 |     if(tp==0 && vis[v][1]==an){
 48 |         flag=false;
 49 |     }
 50 |     if(tp==1 && vis[v][0]==an){
 51 |         flag=false;
 52 |     }
 53 |     vis[v][tp]=an;
 54 |     if(ans[v]=='*'){
 55 |         if(tp==0){
 56 |             ans[v]='+';
 57 |         }else{
 58 |             ans[v]='-';
 59 |         }
 60 |     }
 61 |     
 62 |     for(auto u:graphr[v][tp]){
 63 |         if(vis[u.first][u.second]==0){
 64 |             dfs(u.first,u.second);
 65 |         }
 66 |     }
 67 | 
 68 | }
 69 | 
 70 | 
 71 | 
 72 | int main()
 73 | {
 74 |     ios_base::sync_with_stdio(false);
 75 |     cin.tie(NULL);
 76 | 
 77 |     // ll n;
 78 |     cin >> n>>m;
 79 | 
 80 |     for (ll i = 0; i <n; i++)
 81 |     {
 82 |         ll u,v;
 83 |         char ui,vi;
 84 |         cin>>ui>>u>>vi>>v;
 85 | 
 86 |         ll fui,fvi;
 87 |         fui=(ui=='+')?1:0;
 88 |         fvi=(vi=='+')?1:0;
 89 |         if(fui==0){
 90 |             graph[u][1].push_back({v,fvi});
 91 |             graphr[v][fvi].push_back({u,1});
 92 |         }else{
 93 |             graph[u][0].push_back({v,fvi});
 94 |             graphr[v][fvi].push_back({u,0});
 95 |         }
 96 |         if(fvi==0){
 97 |             graph[v][1].push_back({u,fui});
 98 |             graphr[u][fui].push_back({v,1});
 99 |         }else{
100 |             graph[v][0].push_back({u,fui});
101 |             graphr[u][fui].push_back({v,0});
102 |         }
103 |         
104 |        
105 |     }
106 |     for(ll i=1;i<=m;i++){
107 |         if(!visited[i][0]){
108 |             topo(i,0);
109 |         }
110 |         if(!visited[i][1]){
111 |             topo(i,1);
112 |         }
113 |     }
114 | 
115 |     reverse(order.begin(),order.end());
116 |     
117 |     for(auto i:order){
118 |         if(vis[i.first][i.second]==0){
119 |             an++;
120 |             dfs(i.first,i.second);
121 |             if(!flag){
122 |                 break;
123 |             }
124 |             // an++;
125 |         }
126 |     }
127 |     if(!flag){
128 |         cout<<"IMPOSSIBLE"<<endl;
129 |         return 0;
130 |     }
131 |     for(ll i=1;i<=m;i++){
132 |         cout<<ans[i];
133 |     }
134 |     cout<<endl;
135 |     
136 | 
137 |     return 0;
138 | }
139 | 


--------------------------------------------------------------------------------
/cses graph/1686 Building Teams.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 |  
  3 | // manitianajay45
  4 |  
  5 | // give me some sunshine, give me some rain ,give me another chance to grow up once again....
  6 |  
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | test case for "impossible":
 11 | 3 3
 12 | 1 2 
 13 | 1 3
 14 | 2 3
 15 | 
 16 | basically using level order traversal technique using bfs if on the odd level we will give 1 to all the elements and on even level we will give 2
 17 | or we can use it using dfs simply maintaining a fucntion
 18 | dfs(node,flag);
 19 | where flag will be reverse after each iteration 
 20 | color=flag?1:2;
 21 | */
 22 |  
 23 | #include <bits/stdc++.h>
 24 | using namespace std;
 25 |  
 26 | #define ll int
 27 |  
 28 | ll n, m;
 29 |  
 30 | vector<ll> graph[100005];
 31 |  
 32 | vector<bool> visited(100005, false);
 33 |  
 34 | int main()
 35 | {
 36 |     cin >> n >> m;
 37 |     vector<pair<ll,ll>> edges;
 38 |     for (ll i = 0; i < m; i++)
 39 |     {
 40 |         ll u, v;
 41 |         cin >> u >> v;
 42 |         graph[u].push_back(v);
 43 |         graph[v].push_back(u);
 44 |         edges.push_back({u,v});
 45 |     }
 46 |  
 47 |     queue<ll> q;
 48 |     vector<ll> ans(n + 1, 1);
 49 |     for (ll i = 1; i <= n; i++)
 50 |     {
 51 |         if (!visited[i])
 52 |         {
 53 |             while (!q.empty())
 54 |             {
 55 |                 q.pop();
 56 |             }
 57 |             q.push(i);
 58 |             q.push(-1);
 59 |             ll an = 0;
 60 |             while (q.size() > 1)
 61 |             {
 62 |                 ll u = q.front();
 63 |                 q.pop();
 64 |                 if (u == -1)
 65 |                 {
 66 |                     an++;
 67 |                     q.push(-1);
 68 |                     continue;
 69 |                 }
 70 |  
 71 |                 if (an % 2 == 1)
 72 |                 {
 73 |                     ans[u] = 2;
 74 |                 }
 75 |  
 76 |                 visited[u] = true;
 77 |                 for (auto i : graph[u])
 78 |                 {
 79 |                     if (!visited[i])
 80 |                     {
 81 |                         q.push(i);
 82 |                         visited[i] = true;
 83 |                     }
 84 |                 }
 85 |             }
 86 |         }
 87 |     }
 88 |     bool flag=false;
 89 |     for(ll i=0;i<m;i++){
 90 |         if(ans[edges[i].first]==ans[edges[i].second]){
 91 |             flag=true;
 92 |             break;
 93 |         }
 94 |     }
 95 |  
 96 |     if(flag){
 97 |         cout<<"IMPOSSIBLE"<<endl;
 98 |         return 0;
 99 |     }
100 |  
101 |     for(ll i=1;i<=n;i++){
102 |         cout<<ans[i]<<" ";
103 |     }
104 |     cout<<endl;
105 |  
106 |  
107 |     return 0;
108 | }
109 | 


--------------------------------------------------------------------------------
/cses graph/1686 Coin Collector.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | /*
 10 | steps:-
 11 | 
 12 | firstly merge all the strongly connected componenets and now graph is DAG .
 13 | */
 14 | 
 15 | #include <bits/stdc++.h>
 16 | using namespace std;
 17 | 
 18 | #define ll long long
 19 | #define mod 1000000007
 20 | ll n,m;
 21 | 
 22 | vector<bool> visited(200005,false);
 23 | vector<ll> graph[200005];
 24 | vector<ll> order;
 25 | vector<ll> graphr[200005];
 26 | set<ll> gph[200005];
 27 | vector<ll> vis(200005,0);
 28 | vector<ll> vec(200005,0);
 29 | 
 30 | ll an=0;
 31 | ll weight[200005];
 32 | ll val=0;
 33 | 
 34 | vector<ll> ans(200005,-1);
 35 | 
 36 | 
 37 | void topo(ll v){
 38 |     visited[v]=true;
 39 |     for(auto u:graph[v]){
 40 |         if(!visited[u]){
 41 |             topo(u);
 42 |         }
 43 |     }
 44 |     order.push_back(v);
 45 | }
 46 | bool flag=true;
 47 | 
 48 | void dfs(ll v){
 49 | //    cout<<v<<" ";
 50 |     vis[v]=an;
 51 |     val+=weight[v];
 52 |     for(auto u:graphr[v]){
 53 |         if(vis[u]==0){
 54 |             dfs(u);
 55 |         }else if(vis[u]!=an){
 56 |             gph[vis[u]].insert(an);
 57 |         }
 58 |         
 59 |     }
 60 | 
 61 | }
 62 | 
 63 | 
 64 | ll mx=0;
 65 | 
 66 | ll ansfunc(ll v){
 67 |     if(ans[v]!=-1){
 68 |         return ans[v];
 69 |     }
 70 |     visited[v]=true;
 71 |     ans[v]=vec[v];
 72 |     for(auto u:gph[v]){
 73 |         // if(!visited[u]){
 74 |             ans[v]=max(ans[v],vec[v]+ansfunc(u));
 75 |         // }
 76 |     }
 77 |     return ans[v];
 78 | }
 79 | 
 80 | 
 81 | int main()
 82 | {
 83 |     ios_base::sync_with_stdio(false);
 84 |     cin.tie(NULL);
 85 | 
 86 |     // ll n;
 87 |     cin >> n>>m;
 88 | 
 89 |     for(ll i=1;i<=n;i++){
 90 |         cin>>weight[i];
 91 |     }
 92 | 
 93 |     vector<pair<ll,ll>> edges;
 94 | 
 95 |     for (ll i = 0; i < m; i++)
 96 |     {
 97 |         ll u,v;
 98 |         cin>>u>>v;
 99 |         graph[u].push_back(v);
100 |         graphr[v].push_back(u);
101 |         edges.push_back({u,v});
102 |        
103 |     }
104 |     for(ll i=1;i<=n;i++){
105 |         if(!visited[i]){
106 |             topo(i);
107 |         }
108 |     }
109 | 
110 |     reverse(order.begin(),order.end());
111 | 
112 |     // vec.push_back(0);
113 |     for(auto i:order){
114 |         if(vis[i]==0){
115 |             an++;
116 |             val=0;
117 |             dfs(i);
118 |             vec[an]=val;
119 |         
120 |         }
121 |     }
122 |     
123 |     for(ll i=1;i<=an;i++){
124 |         if(ans[i]==-1){
125 |             // cout<<i<<" ";
126 |             mx=max(mx,ansfunc(i));
127 |             // cout<<ansfunc(i)<<endl;````````````````````
128 |         }
129 |     }
130 |     cout<<mx<<endl;
131 |     
132 | 
133 |     return 0;
134 | }
135 | 


--------------------------------------------------------------------------------
/cses graph/1750 PlanetQueries1.cpp:
--------------------------------------------------------------------------------
 1 | // JAI BAJARANG BALI
 2 |  
 3 | // manitianajay45
 4 |  
 5 | // give me some sunshine, give me some rain, give me another chance to grow up once again....
 6 |  
 7 | // sab moh maya hai....
 8 |  
 9 | #include <bits/stdc++.h>
10 | using namespace std;
11 |  
12 | #define ll long long
13 | #define mod 1000000007
14 | 
15 | vector<ll> graph[200005];
16 | 
17 | vector<ll> ans(200005,0);
18 | 
19 | vector<bool> visited(200005,false);
20 | 
21 | ll dp[200005][31];
22 | 
23 | ll n,q;
24 | 
25 | 
26 | 
27 | void binlift(){
28 |     for(ll i=1;i<31;i++){
29 |         for(ll j=1;j<=n;j++){
30 |             dp[j][i]=dp[dp[j][i-1]][i-1];
31 |         }
32 |     }
33 | }
34 | 
35 | ll query(ll x,ll k){
36 |     ll prev=x;
37 |     for(ll i=31;i>=0;i--){
38 |         if((k>>i)&1){
39 |             // cout<<i<<"i"<<endl;
40 |             prev=dp[prev][i];
41 |             
42 | 
43 |         }
44 |     }    
45 |     return prev;
46 | }
47 | 
48 | 
49 | 
50 | int main()
51 | {
52 |     ios_base::sync_with_stdio(false);
53 |     cin.tie(NULL);
54 |     cin>>n>>q;
55 |     ll arr[n+1];
56 |     memset(dp,-1,sizeof(dp));
57 |     for(ll i=1;i<=n;i++){
58 |         cin>>arr[i];
59 |         dp[i][0]=arr[i];
60 |         
61 |     }
62 |     // for(ll i=1;i<=n;i++)
63 |     // {
64 |     //     for(ll j=0;j<=3;j++){
65 |     //         cout<<dp[i][j]<<" ";
66 |     //     }
67 |     //     cout<<endl;
68 |     // }
69 |     // cout<<"YES"<<endl;
70 | 
71 |     binlift();
72 |     while(q--){
73 |         ll x,k;
74 |         cin>>x>>k;
75 | 
76 |         ll ans=query(x,k);
77 |         cout<<ans<<endl;
78 |     }    
79 |     return 0;
80 | }
81 | 


--------------------------------------------------------------------------------
/cses graph/1751-PlanetsCycles.cpp:
--------------------------------------------------------------------------------
  1 | // JAI BAJARANG BALI
  2 | 
  3 | // manitianajay45
  4 | 
  5 | // give me some sunshine, give me some rain , give me another chance to grow up once again....
  6 | 
  7 | // sab moh maya hai....
  8 | 
  9 | 
 10 | /*
 11 | steps:-
 12 | 1. firstly try to find out a cycle and its length then assign every node value equal to cycle length.
 13 | 2. after that start traverse back to eveynodes parent and ans[par]=ans[child]+1; if(ans[par] not find before);
 14 | 
 15 | 3. there would be one more case if we traversing node and we have already ans of a child then we started to traverse back from there:
 16 |   ans[par]=ans[child]+1; if(ans[par] not find before);
 17 |   
 18 | */
 19 | 
 20 | 
 21 | #include <bits/stdc++.h>
 22 | using namespace std;
 23 | 
 24 | #define ll long long
 25 | #define mod 1000000007
 26 | ll n;
 27 | 
 28 | 
 29 | vector<ll> graph[200005];
 30 | vector<ll> visited(200005,0);
 31 | vector<ll> par(200005,-1);
 32 | vector<pair<ll,bool>> ans(200005,{0,false});
 33 | ll cl=1;
 34 | void dfs(ll v){
 35 |     visited[v]=cl;
 36 |     for(auto u:graph[v]){
 37 |         if(visited[u]==0){
 38 |             par[u]=v;
 39 |             dfs(u);
 40 |         }
 41 | 
 42 |         if(visited[u]==cl){
 43 |             ll st=v;
 44 |             ll cyc=0;
 45 |             while(st!=u){
 46 |                 cyc++;
 47 |                 st=par[st];
 48 |             }
 49 |             st=v;
 50 |             cyc++;
 51 |             while(st!=u){
 52 |                 ans[st].first=cyc;
 53 |                 st=par[st];
 54 |             }
 55 |             // cyc++;
 56 |             ans[st].first=cyc;
 57 |             ans[st].second=true;
 58 |             ll prev=st;
 59 |             while(st!=-1){
 60 |                 prev=st;
 61 |                 st=par[st];
 62 |                 if(!ans[st].second){
 63 |                     ans[st].first=ans[prev].first+1;
 64 |                     ans[st].second=true;
 65 |                 }
 66 |             }
 67 |         }else if(visited[u]!=(-1*cl)){
 68 |             // cout<<"UES"<<endl;
 69 |             // cout<<u<<endl;
 70 |             ll st=v;
 71 |             ll prev=u;
 72 |             while(st!=-1 ){
 73 |                 if(!ans[st].second){
 74 |                     ans[st].first=ans[prev].first+1;   
 75 |                     ans[st].second=true;
 76 |                 } 
 77 |                 prev=st;
 78 |                 st=par[st];            
 79 |             }
 80 |             
 81 |             
 82 |         }
 83 |     }
 84 |     visited[v]=(-1*cl);
 85 | }
 86 | 
 87 | 
 88 | int main()
 89 | {
 90 |     ios_base::sync_with_stdio(false);
 91 |     cin.tie(NULL);
 92 | 
 93 |     // ll n;
 94 |     cin >> n;
 95 | 
 96 |     for (ll i = 1; i <=n; i++)
 97 |     {
 98 |         ll x;
 99 |         cin>>x;
100 |         
101 |         graph[i].push_back(x);
102 |     }   
103 |     for(ll i=1;i<=n;i++){
104 |         if(visited[i]==0){
105 |             dfs(i);
106 |             cl++;
107 |         }
108 |     }
109 | 
110 | 
111 |     for(ll i=1;i<=n;i++){
112 |         cout<<ans[i].first<<" ";
113 |     }
114 |     cout<<endl;
115 | 
116 | 
117 | 
118 |     return 0;
119 | }
120 | 


--------------------------------------------------------------------------------
/cses graph/README.MD:
--------------------------------------------------------------------------------
 1 | solve cses problemset and learn concept with problems.
 2 | 
 3 | # CP algothims:- 
 4 | https://cp-algorithms.com/
 5 | 
 6 | # CSES handbook :- 
 7 | https://cses.fi/book/book.pdf
 8 | 
 9 | Uploading problem soln in same repo with discription.
10 | 
11 | 


--------------------------------------------------------------------------------
/playing with bits/readme.md:
--------------------------------------------------------------------------------
1 | here are some collection problem regrading bits.
2 | 


--------------------------------------------------------------------------------