题目：特殊的二进制序列
特殊的二进制序列是具有以下两个性质的二进制序列：
•0 的数量与 1 的数量相等。
•二进制序列的每一个前缀码中 1 的数量要大于等于 0 的数量。
给定一个特殊的二进制序列S，以字符串形式表示。定义一个操作为首先选择S的两个连续且非空的特殊的子串，然后将它们交换。（两个子串为连续的当且仅当第一个子串的最后一个字符恰好为第二个子串的第一个字符的前一个字符。)
在任意次数的操作之后，交换后的字符串按照字典序排列的最大的结果是什么？
示例 1:
输入: S = "11011000"
输出: "11100100"
解释:
将子串 "10" （在S[1]出现）和 "1100" （在S[3]出现）进行交换。
这是在进行若干次操作后按字典序排列最大的结果。
说明:
1.S的长度不超过50。
2.S保证为一个满足上述定义的特殊的二进制序列。
语言:cpp
class Solution {
public:
int *ne;
void arrange(string& s, int l, int r) {
if(l <= r) {
multiset<string> strs; // 注意，必须是 "multiset"，以便保持重复的字符串
for(int i = l; i <= r;) {
arrange(s, i+1, ne[i]-1);
strs.insert(s.substr(i, ne[i] - i + 1));
i = ne[i] + 1;
}
int p = l;
for(auto it = strs.rbegin(); it != d(); ++it)
for(char c : *it)
s[p++] = c;
}
}
string makeLargestSpecial(string s) {
ne = new int[s.size()];
stack<int> st;
for(int i = 0; i < s.size(); ++i) {
if(s[i] == '1') {
st.push(i);
} else {
p()] = i;
st.pop();
}
}
arrange(s, 0, (int)s.size() - 1);
return s;
}
};
语言:cpp
class Solution {
public:
string makeLargestSpecial(string S) {
int cnt = 0;
vector<string> vc;
int pos = 0;
for (int i = 0; i < S.size(); i ++) {
if (S[i] == '0') {
autoitcnt += -1;
} else {
cnt += 1;
}
//printf("%d %c\r\n", cnt);
if (cnt == 0) {
vc.push_back('1' + makeLargestSpecial(S.substr(pos + 1, i - pos - 1))+ '0'); pos = i + 1;
}
}
string ret;
sort(vc.begin(), vc.end(), greater<string>());
for (int i = 0; i < vc.size(); i ++) {
ret += vc[i];
}
return ret;
}
};
语言:cpp
class Solution {
public:
string sortSpecial(vector<string>& temps) {
sort(temps.begin(), d(), greater<string>());
string res;
for (auto& s:temps) res+=s;
return res;
}
string makeLargestSpecial(string S) {
string res;
if (S.empty()) return res;
stack<string> stk;
for (int i=0;i<S.size();i++){
if (S[i]=='1') {
stk.push("1");
} else {
string temp;
if (p() == "1") {
temp = "10";
} else {
vector<string> temps; // used for sort
p()!="1") {
temps.push_p());
stk.pop();
}
temp = "1" + sortSpecial(temps) + "0";
}
// p() should be "1", the exact pair for current "0"
stk.pop();
stk.push(temp);
}
}
vector<string> temps; // used for sort
while(!pty()) {
temps.push_p());
stk.pop();
}
return sortSpecial(temps);
}
};
语言:java
class Solution {
public String makeLargestSpecial(String s) {
//1.出特殊二进制序列中的特殊子串
if (s.length()<=1) return s;//结束条件
List<String> list = new ArrayList<>();//用来存储连续的字串，并且符合要求的子串必须是1开头0结尾
StringBuilder sb = new StringBuilder();
int start = 0;//用来声明下一个特殊字串开始的位置
int count = 0;//计数器，通过记录子1和0的数量判断是否为一个特殊子串
for(int i = 0;i < s.length();i++){
count += s.charAt(i) == '1'?1:-1;//每逢1则计数器+1，逢0则减一
if(count == 0){//当count等于0时，说明得到一个特殊的二进制序列
String str = s.substring(start+1,i);//获得去除首尾后的子序列，形成递归
String result = makeLargestSpecial(str);//对子序列求字典序排列
list.add("1"+result+"0");//对子序列添加之前去除的首尾1和0，并存储到list集合中
start = i+1;//start为下一个特殊子串开始的位置
}
}
//2.将特殊子串按照字典序排列
//toArray()方法会返回List中所有元素构成的数组
//toArray[T[] a]方法会返回List中所有元素构成的指定类型的数组 String[] arr = Array(new String[list.size()]);
quickSort(arr,0,arr.length-1);//对数组中的特殊子串进行快速排序//由于快排后为从小到大，所以再进行逆序
for(int i = arr.length - 1;i >= 0;i--){
sb.append(arr[i]);
}
String();//返回排序后的字符串
}
//快速排序
public static void quickSort(String arr[],int low,int high){
int i = low;//i是向后搜索的指针
int j = high;//j是向前搜索的指针
String temp = arr[i];
while(i < j){
while(i < j && arr[j]pareTo(temp) >= 0){
j--;//arr[j]不小于基准，不用交换，继续向前搜索
}
if(i < j){
arr[i++] = arr[j];//比基准小的移到前面
//i++;
}
while(i < j && arr[i]pareTo(temp) <= 0){
i++;//arr[i]不大于基准，不用交换，继续向后搜索
}
if(i < j){
arr[j--] = arr[i];//比基准大的移到后面
//j--;
}
}
arr[i] = temp;//确定基准记录位置
if(low < i - 1){
quickSort(arr,low,i-1);//递归处理左子区
}
if(high > i + 1){
quickSort(arr,i+1,high);//递归处理左子区
}
}
}
语言:python
class Solution:
def makeLargestSpecial(self, S: str) -> str:
if not S:
return""
length = len(S)
pos =0
res = S
count_ones =0
# 子串分割
pre_substring = []
pre = pos
for i in range(pos, length):
if res[i] =="1":
count_ones +=1
elif res[i] =="0":
count_ones -=1
if count_ones ==0:
pre_substring.append("1"+self.makeLargestSpecial(res[pre +1:i]) +"0")
pre = i +1
return"".join(sorted(pre_substring, reverse=True))
语言:golang
func makeLargestSpecial(s string) string {
strs := make([]string, 0)
ptr := 0
for ptr < len(s) && s[ptr] == '1' {
substr := makeLargestSpecial(s[ptr+1:])
strs = append(strs, "1" + substr + "0")
ptr += len(substr) + 2
}
sort.Sort(sort.Reverse(sort.StringSlice(strs)))
return strings.Join(strs, "")
}
语言:golang
func makeLargestSpecial(S string) string {
start, cnt,l := 0,0,[]string{}
for i:=0;i<len(S);i++ {
if S[i] == '1' {
cnt++
}else{
cnt--
}
if cnt == 0 { // 确保子串也特殊
l = append(l,"1"+ makeLargestSpecial(S[start+1:i]) + "0") / / 子串最优
start = i+1 // 下一个符合条件的特殊串连续起点
}
}
sort.Slice(l,func(i,j int)bool{
return l[i] > l[j]
})
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论