From 65b4e1d652b6fb2d272ec7a7d5aca8e498bf24a7 Mon Sep 17 00:00:00 2001
From: wisdompeak <guan.huifeng@gmail.com>
Date: Thu, 12 Jun 2025 00:52:35 -0700
Subject: [PATCH 1/4] Create
 3579.Minimum-Steps-to-Convert-String-with-Operations.cpp

---
 ...teps-to-Convert-String-with-Operations.cpp | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/3579.Minimum-Steps-to-Convert-String-with-Operations.cpp

diff --git a/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/3579.Minimum-Steps-to-Convert-String-with-Operations.cpp b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/3579.Minimum-Steps-to-Convert-String-with-Operations.cpp
new file mode 100644
index 000000000..ef82e0a18
--- /dev/null
+++ b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/3579.Minimum-Steps-to-Convert-String-with-Operations.cpp
@@ -0,0 +1,46 @@
+class Solution {
+    int count[26][26];
+public:
+    int helper(string& word1, string&word2) {
+        fill(&count[0][0], &count[0][0]+26*26, 0);
+
+        int n = word1.size();
+        for (int k=0; k<n; k++) {
+            if (word1[k]==word2[k]) continue;
+            count[word1[k]-'a'][word2[k]-'a']++;
+        }
+
+        int ans = 0;
+        for (int a=0; a<26; a++)
+            for (int b=0; b<26; b++) {
+                int common = min(count[a][b], count[b][a]);
+                ans+=common;
+                count[a][b]-=common;
+                count[b][a]-=common;
+                ans+=count[a][b];
+            }
+        return ans;
+    }
+
+    int minOperations(string word1, string word2) {
+        int n = word1.size();
+        vector<int>dp(n, INT_MAX/2);
+
+        for (int j=0; j<n; j++)
+            for (int i=0; i<=j; i++) {
+                int ans = INT_MAX/2;
+                string a = word1.substr(i,j-i+1);
+                string b = word2.substr(i,j-i+1);
+                ans = min(ans, helper(a,b));
+
+                string rev = a;
+                reverse(rev.begin(), rev.end());                
+                ans = min(ans, helper(rev,b)+1);
+    
+                dp[j] = min(dp[j], (i==0?0:dp[i-1])+ans);
+            }
+
+        return dp[n-1];
+        
+    }
+};

From 55a147429ade5c2d40dc023e39fe3c0cf7f51512 Mon Sep 17 00:00:00 2001
From: wisdompeak <guan.huifeng@gmail.com>
Date: Thu, 12 Jun 2025 00:53:01 -0700
Subject: [PATCH 2/4] Update Readme.md

---
 Readme.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Readme.md b/Readme.md
index 467bd6625..28e1d55b4 100644
--- a/Readme.md
+++ b/Readme.md
@@ -887,6 +887,7 @@
 [2547.Minimum-Cost-to-Split-an-Array](https://github.com/wisdompeak/LeetCode/tree/master/Dynamic_Programming/2547.Minimum-Cost-to-Split-an-Array) (M)      
 [2911.Minimum-Changes-to-Make-K-Semi-palindromes](https://github.com/wisdompeak/LeetCode/tree/master/Dynamic_Programming/2911.Minimum-Changes-to-Make-K-Semi-palindromes) (H-)      
 [3077.Maximum-Strength-of-K-Disjoint-Subarrays](https://github.com/wisdompeak/LeetCode/tree/master/Dynamic_Programming/3077.Maximum-Strength-of-K-Disjoint-Subarrays) (M+)      
+[3579.Minimum-Steps-to-Convert-String-with-Operations](https://github.com/wisdompeak/LeetCode/tree/master/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations) (H-)      
 * ``区间型 II``   
 [131.Palindrome-Partitioning](https://github.com/wisdompeak/LeetCode/tree/master/Dynamic_Programming/131.Palindrome-Partitioning) (M+)  
 [312.Burst-Balloons](https://github.com/wisdompeak/LeetCode/tree/master/DFS/312.Burst-Balloons) (H-)   

From bdbfd11c72c4b0d566abc8e423f3b59344cfcfb5 Mon Sep 17 00:00:00 2001
From: wisdompeak <guan.huifeng@gmail.com>
Date: Thu, 12 Jun 2025 01:13:26 -0700
Subject: [PATCH 3/4] Create Readme.md

---
 .../Readme.md                                              | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md

diff --git a/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md
new file mode 100644
index 000000000..324dedd31
--- /dev/null
+++ b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md
@@ -0,0 +1,7 @@
+3579.Minimum-Steps-to-Convert-String-with-Operations
+
+对于区间的问题，我们会思考用区间型的DP是否可行。我们自然会令dp[i]表示针对前i个元素，变换成功所需要的最少操作次数。接下来就是要考虑最后一个区间的位置起点j。因为本题里字符串的长度只有100，我们可以考虑遍历起点j。这样问题就转化为对于区间[j:i]，变化成功所需要的最少操作次数，这样就有`dp[i]=dp[j-1]+helper(j,i)`.
+
+注意到题意中的翻转操作最多只需要一次，我们可以将问题分解成两遍：将word1[j:i]变成Word[j:i]所需要的最少操作数；再将前者翻转一下，同样求变成Word[j:i]所需要的最少操作数。
+
+接下来我们就是设计这样的一个函数，将字符串A怎样高效地只通过swap和replace变成B。贪心是行得通的，因为同一个字符只能用swap或者replace，显然优先使用swap，这样一次操作解决两个地方；等能用的swap都用完了，自然用replace就可以解决剩余的问题。我们用count[a][b]现统计对于字符串A里，字符a需要变成字符b的个数。然后用两个26的循环，遍历所有所有的字符配对{x,y}。显然count[x][y]和count[y][x]可以尽可能地互相抵消，能抵消的就算是swap的操作，剩余不能抵消的部分就是需要的replace的操作。

From 5177d69c10f736983dd627d623b3685a12098f8b Mon Sep 17 00:00:00 2001
From: wisdompeak <guan.huifeng@gmail.com>
Date: Thu, 12 Jun 2025 01:13:35 -0700
Subject: [PATCH 4/4] Update Readme.md

---
 .../Readme.md                                                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md
index 324dedd31..c990e1e94 100644
--- a/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md
+++ b/Dynamic_Programming/3579.Minimum-Steps-to-Convert-String-with-Operations/Readme.md
@@ -1,4 +1,4 @@
-3579.Minimum-Steps-to-Convert-String-with-Operations
+### 3579.Minimum-Steps-to-Convert-String-with-Operations
 
 对于区间的问题，我们会思考用区间型的DP是否可行。我们自然会令dp[i]表示针对前i个元素，变换成功所需要的最少操作次数。接下来就是要考虑最后一个区间的位置起点j。因为本题里字符串的长度只有100，我们可以考虑遍历起点j。这样问题就转化为对于区间[j:i]，变化成功所需要的最少操作次数，这样就有`dp[i]=dp[j-1]+helper(j,i)`.