update

Author: mustankap

.classpath

@@ -7,5 +7,6 @@
 	</classpathentry>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="src" path="CSES/Introductory Problems"/>
+	<classpathentry kind="src" path="heisenburg2.0"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

CSES/Dynamic Programming/Dice_Combinations.class

@@ -0,0 +1,29 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+ 
+public class Dice_Combinations {
+    
+    public static void main(String[] args)throws IOException {
+        
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n=Integer.parseInt(br.readLine());
+       
+        int dp[]= new int[n+1];
+        dp[0]=1;
+        dp[1]=1;
+        int k=6;
+            
+        dp[0]=dp[1]=1;
+        
+        for(int i=2;i<=k;i++)
+        dp[i] = 2*dp[i-1];
+     
+        for(int i=k+1;i<=n;i++)
+        dp[i] = 2*dp[i-1]-dp[i-k-1];
+
+        System.out.println(dp[n]);
+    }
+}
+

CSES/Dynamic Programming/Dice_Combinations.java

@@ -0,0 +1,76 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define MOD 1000000007
+#define M 1001
+#define fastIO ios_base::sync_with_stdio(false);cin.tie(NULL);
+#define w(t) ll t;cin >> t;while (t--)
+//#define sort(a) sort(a.begin(), a.end());
+using namespace std;
+
+ll a[M], pows[M], c[M][M];
+// void hk(){
+// #ifndef ONLINE_JUDGE
+//     freopen("input49.txt", "r", stdin);
+//     freopen("output49.txt", "w", stdout);
+// #endif
+// }
+
+int main()
+{
+    fastIO;
+
+    memset(a, 0, sizeof(a));
+    memset(c, 0, sizeof(c));
+    memset(pows, 0, sizeof(pows));
+
+    pows[0] = 1;
+    pows[1] = 1;
+
+
+    for (ll i = 2; i <= 1000; i++)
+    {
+        pows[i] = (pows[i - 1] * 2) % MOD;
+    }
+
+
+
+    c[0][0] = 1;
+    for (int i = 1; i <= 1000; i++)
+    {
+        c[i][0] = 1;
+        for (int j = 1; j <= i; j++)
+        {
+            c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
+        }
+    }
+    
+    
+    ll m, n;
+    cin >> n >> m;
+
+    for (ll i = 1; i <= m; i++)
+    {
+        cin >> a[i];
+    }
+
+    sort(a + 1, a + m + 1);
+
+    ll sum = 1;
+    ll d = n - m;
+
+    for (int i = 1; i <= m; i++)
+    {
+        sum = (sum * c[d][a[i] - a[i - 1] - 1]) % MOD;
+        d -= a[i] - a[i - 1] - 1;
+    }
+
+    for (int i = 2; i <= m; i++)
+    {
+        sum = (sum * pows[a[i] - a[i - 1] - 1]) % MOD;
+    }
+
+    
+    cout << sum << "\n";
+
+    return 0;
+}

heisenburg2.0/Vacc_permutation.cpp

@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+#define ll long long
+#define pb emplace_back
+#define fr first
+#define sc second
+#define endl "\n"
+using namespace std;
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    ll t;
+    cin >> t;
+    while(t--){
+        ll a, b;
+        cin >> a >> b;
+        string s;
+        cin >> s;
+        if(count(s.begin() , s.end() , '0') == s.size()){
+            cout << "0" << endl;
+            continue;
+        }
+        int m = 0  , d = -1 , i = 0 , c , n = s.size();
+        while( i < n ){
+            c = 0;
+            int st = i;
+
+            while(s[i%n] == '0'){
+                c++;
+                i++;
+            }
+            if(c > m){
+                m = c;
+                d = st;
+            }
+            i++;
+        }
+        
+        ll ans = a;
+        c = 0;
+        if(m == 0){
+            cout << ans << endl;
+            continue;
+        }
+        c= 0;
+        for(int i = m + d; (i)%n != d;i++){
+            if(s[i%n]=='0'){
+                c++;
+            } else {
+                ans = ans + min(c*b , a);
+                c = 0;
+            }
+        }
+        
+        cout << ans << endl;
+    }
+    return 0;
+}

heisenburg2.0/a.out

@@ -0,0 +1,39 @@
+for _ in range(int(input())):
+    ab=list(map(int,input().split()))
+    a,b=ab[0],ab[1]
+    s=list(map(int,input()))
+    n=len(s)
+    v=[]
+    for i in range(n):
+        if s[i] == 0:
+            if i == 0  or  s[i-1] == 1:
+               v.append(0)
+            v[-1]=v[-1]+1
+    
+    if len(v)==1 and v[0]==n:
+        print(0)
+        continue
+    
+    ans=a
+
+    if v!=[]:
+        if s[0] == 0 and  s[n-1] == 0:
+            n = v[-1]
+            v.pop(-1)
+            
+            if v==[]:
+                v.append(n)
+            else:
+                v[0]=v[0]+n
+        sorted(v)
+        v.pop(-1)
+        n=len(v)
+        for i in range(n):
+            ans+=min(b*v[i],a)
+    print(ans)
+                
+                
+
+
+            
+        

heisenburg2.0/cd.cpp

@@ -0,0 +1,86 @@
+
+import java.io.*;
+import java.util.*;
+
+public class circular_dominos {
+    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
+    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
+    static StringTokenizer input;
+    static final int IBIG = 1000000007;
+
+    static String rline() throws IOException {return __in.readLine();}
+    static int ri() throws IOException {return Integer.parseInt(rline());}
+    static void r() throws IOException {input = new StringTokenizer(rline());}
+    static String n() {return input.nextToken();}
+    static int rni() throws IOException {r(); return ni();}
+    static int ni() {return Integer.parseInt(n());}
+    static char[] rcha() throws IOException {return rline().toCharArray();}
+    static void prln(int i) {__out.println(i);}
+    static void close() {__out.close();}
+    public static void main(String[] args) throws IOException {
+        int t = ri();
+        while (t --> 0) {
+            int a = rni(), b = ni();
+            String s=rline();
+            int n = s.length();
+            int i = 0;
+            
+            List<Integer> v = new ArrayList<>();
+
+            for(i=0; i<n; i++)
+            {
+                if(s.charAt(i) == '0')
+                {
+                    if(i == 0  ||  s.charAt(i-1) == '1')
+                    {
+                        v.add(0);
+                    }
+                    v.set(v.size()-1,v.get(v.size()-1)+1);
+                
+                }
+            }
+
+            
+
+            if(v.size() == 1  &&  v.get(0) == n)
+            {
+                prln(0);
+                continue;
+            }
+
+            int ans = a;
+            if(v.isEmpty()==false)
+            {
+                if(s.charAt(0) == '0'  &&  s.charAt(n-1) == '0')
+                {
+                    n = v.get(v.size()-1);
+                    v.remove(v.size() - 1);
+                    
+                    if(v.isEmpty())
+                    {
+                        v.add(n);
+                    }
+                    else 
+                    {
+                        v.set(0,v.get(0)+n);
+                    }
+                }
+
+                Collections.sort(v);
+                
+                v.remove(v.size() - 1);
+
+                n=v.size();
+                
+                for(i=0; i<n; i++)
+                {
+                    ans+=Math.min(b*v.get(i),a);
+                }
+            }
+            prln(ans);
+        }
+        close();
+    }
+
+}
+