feat: 实现动态规划解决奶牛逃跑问题

添加P4267.cpp文件，实现动态规划算法计算奶牛逃跑序列的最小修改次数。算法使用二维DP数组存储状态，并通过预处理计算区间修改成本。解决给定n头奶牛在不同逃跑次数下的最小不一致数量问题。

src/8/27/P1880.cpp

@@ -1,32 +0,0 @@
-/*
-
-
-
-*/
-#include <cstdint>
-#include <iostream>
-#include <stdexcept>
-#include <vector>
-using ll = int64_t;
-
-int main(){
-    ll n;
-    std::cin>>n;
-    std::vector<ll> arr(n*2+1);
-    std::vector<ll> pre(n*2+1);
-    for(ll i=1;i<=n;i++){
-        std::cin>>arr[i];
-        arr[n+i]=arr[i];
-    }
-    for(ll i=1;i<=2*n;i++){
-        pre[i]=pre[i-1]+arr[i];
-    }
-    std::vector<std::vector<ll>> dp;
-    for(ll i=1;i<n;i++){
-        ll j=i+n-1;
-        dp.clear();
-        dp.resize(2*n+1,std::vector<ll>(2*n+1,1e9));
-        // for(ll x=1;)
-        throw std::runtime_error("NotImpletmented");
-    }
-}

src/8/28/P4267.cpp

@@ -1,3 +0,0 @@
-int main(){
-    
-}

src/8/28/P4342.cpp

@@ -24,6 +24,7 @@ dpmin[i][j] =  1e9
 dp[i][i]=arr[i]
 
 */
+#include <algorithm>
 #include <cstdint>
 #include <iostream>
 #include <istream>
@@ -51,17 +52,61 @@ int main(){
         op[i+n]=op[i];
     }
     std::vector<std::vector<ll>> dpmax,dpmin;
-    for(ll s=1;s<n;s++){
-        ll e = s+n-1;
-        dpmax.clear();
-        dpmax.resize(n21,std::vector<ll>(n21,-1e9));
-        dpmin.clear();
-        dpmin.resize(n21,std::vector<ll>(n21,1e9));
-        for(ll i=s;i<=e;i++){
-            dpmax[i][i]=op[i][1];
-        }
-        for(ll i=s;i<=e;i++){
-            
+    dpmax.clear();
+    dpmax.resize(n21,std::vector<ll>(n21,-1e9));
+    dpmin.clear();
+    dpmin.resize(n21,std::vector<ll>(n21,1e9));
+    for(ll i=1;i<=2*n;i++){
+        dpmax[i][i]=op[i][1];
+        dpmin[i][i]=op[i][1];
+    }
+    for(ll len=2;len<=n;len++){
+        for(ll i=1;i<=2*n-len;i++){
+            ll j=i+len-1;
+            for(ll k=i;k<j;k++){
+                if(op[k+1][0]==add){ //注意是k+1
+                    dpmax[i][j]=std::max(
+                        dpmax[i][k]+dpmax[k+1][j],
+                        dpmax[i][j]
+                    );
+                    dpmin[i][j]=std::min(
+                        dpmin[i][k]+dpmin[k+1][j],
+                        dpmin[i][j]
+                    );
+                }else{
+                    dpmax[i][j]=std::max({
+                        dpmax[i][j],
+                        dpmax[i][k]*dpmax[k+1][j],
+                        dpmin[i][k]*dpmin[k+1][j],
+                        dpmax[i][k]*dpmin[k+1][j],
+                        dpmin[i][k]*dpmax[k+1][j]
+                    });
+                    dpmin[i][j]=std::min({
+                        dpmin[i][j],
+                        dpmax[i][k]*dpmax[k+1][j],
+                        dpmin[i][k]*dpmin[k+1][j],
+                        dpmax[i][k]*dpmin[k+1][j],
+                        dpmin[i][k]*dpmax[k+1][j]
+                    });
+                }
+            }
         }
     }
+    ll ans=-1e9;
+    std::vector<ll> edgs;
+    for(ll i=1;i<=n;i++){
+        ll nans=dpmax[i][i+n-1];
+        if(nans>ans){
+            ans=nans;
+            edgs.clear();
+            edgs.push_back(i);
+        }else if(nans==ans){
+            edgs.push_back(i);
+        }
+    }
+    std::cout<<ans<<"\n";
+    for(ll i:edgs){
+        std::cout<<i<<" ";
+    }
+    std::cout<<"\n";
 }

src/8/29/P1880.cpp

@@ -0,0 +1,54 @@
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <istream>
+#include <vector>
+using ll = int64_t;
+
+const ll inf=1e9;
+
+int main(){
+    std::iostream::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+    std::cout.tie(nullptr);
+
+    ll n;
+    std::cin>>n;
+    std::vector<std::vector<ll>> dpmax(2*n+1,std::vector<ll>(2*n+1,-inf)),
+                                    dpmin(2*n+1,std::vector<ll>(2*n+1,inf)),
+                                    cost(2*n+1,std::vector<ll>(2*n+1));
+
+    for(ll i=1;i<=n;i++){
+        std::cin>>cost[i][i];
+        cost[n+i][n+i]=cost[i][i];
+        dpmin[i][i]=dpmax[i][i]=0;
+        dpmin[n+i][n+i]=dpmax[n+i][n+i]=0;
+    }
+
+    for(ll len=2;len<=n;++len){
+        for(ll i=1;i<=2*n-len;i++){
+            ll j=i+len-1;
+            for(ll k=i;k<j;k++){
+                cost[i][j]=cost[i][k]+cost[k+1][j];
+            }
+        }
+    }
+
+    for(ll len=2;len<=n;len++){
+        for(ll i=1;i<=2*n-len;i++){
+            ll j=i+len-1;
+            for(ll k=i;k<j;k++){
+                dpmax[i][j]=std::max(dpmax[i][j],dpmax[i][k]+dpmax[k+1][j]+cost[i][j]);
+                dpmin[i][j]=std::min(dpmin[i][j],dpmin[i][k]+dpmin[k+1][j]+cost[i][j]);
+            }
+        }
+    }
+
+    ll minans=inf,maxans=-inf;
+    for(ll i=1;i<=n;i++){
+        minans=std::min(minans,dpmin[i][i+n-1]);
+        maxans=std::max(maxans,dpmax[i][i+n-1]);
+    }
+
+    std::cout<<minans<<"\n"<<maxans<<"\n";
+}   

src/8/29/P4267.cpp

@@ -0,0 +1,74 @@
+/*
+
+dp[i][j]=前i个牛发生j次逃跑时序列不一致的数量最小数目
+
+dp[i][j]=min(dp[k][j-1]+cnt[k+1][i])
+
+dp[i][j]=inf
+
+dp[i][1]=cnt[1][i]
+
+*/
+
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <istream>
+#include <vector>
+using ll = int64_t;
+
+const ll inf=1e9;
+
+#define p2v(arr)do{\
+    std::cout<<#arr<<":\n";\
+    for(auto&i:(arr)){\
+        for(auto&j:i){\
+            std::cout<<j<<", ";\
+        }\
+        std::cout<<"\n";\
+    }\
+}while(0)
+
+int main(){
+    std::iostream::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    ll n;
+    std::cin>>n;
+    std::vector<std::vector<ll>> dp(n+1,std::vector<ll>(n+1, inf)),
+            cnt(n+1,std::vector<ll>(n+1));
+    std::vector<ll> arr(n+1);
+    for(ll i=1;i<=n;i++){
+        std::cin>>arr[i];
+    }
+    /*
+    cost[i][j] 表示在区间 [i, j] 内，假设第 i 天发生逃跑，
+    并且在 (i, j] 区间内没有其他逃跑发生时，需要修改的记录数。
+    */
+    for(ll i=1;i<=n;i++){
+        ll mis=0;
+        for(ll j=i;j<=n;j++){
+            if(j-i!=arr[j]){
+                mis++;
+            }
+            cnt[i][j]=mis;
+        }
+    }
+    // p2v(cnt);
+    for(ll i=1;i<=n;i++){
+        dp[i][1]=cnt[1][i];
+    }
+    for(ll i=1;i<=n;i++){
+        for(ll j=2;j<=n;j++){
+            for(ll k=j-1;k<i;k++){
+                dp[i][j]=std::min(
+                    dp[i][j],
+                    dp[k][j-1]+cnt[k+1][i]
+                );
+            }
+        }
+    }
+    for(ll j=1;j<=n;j++){
+        std::cout<<dp[n][j]<<"\n";
+    }
+}