2023-05-27：给你一个只包含小写英文字母的字符串 s 。 每一次 操作 ，你可以选择 s 中两个 相邻 的字符，并将它们交换。 请你返回将 s 变成回文串的 最少操作次数 。 注意 ，输入数据

2023-05-27：给你一个只包含小写英文字母的字符串 s 。

每一次 操作 ，你可以选择 s 中两个 相邻 的字符，并将它们交换。

请你返回将 s 变成回文串的 最少操作次数 。

注意 ，输入数据会确保 s 一定能变成一个回文串。

输入：s = "letelt"。

输出：2。

答案 2023-05-27：

大体过程如下：

1. 定义结构体 IndexTree，其中包含一个整型切片 tree 和整型变量 n，用于实现树状数组。

2. 定义函数 createIndexTree(size int) *IndexTree，用于创建一个大小为 size 的树状数组并初始化，返回该数组的指针。

3. 定义函数 sum(it *IndexTree, i int) int，用于求以 i 为结尾的前缀和。

4. 定义函数 add(it *IndexTree, i int, v int)，用于将第 i 个位置上的值增加 v。

5. 定义函数 merge(arr []int, help []int, l int, m int, r int) int，用于归并排序并统计逆序对数量。

6. 定义函数 number(arr []int, help []int, l int, r int) int，用于递归地求解整个序列中的逆序对数量。

7. 定义函数 minMovesToMakePalindrome(s string) int，用于求解将字符串 s 变成回文串的最少操作次数。首先遍历字符串，将每个字符第一次出现的下标加入到对应字符的索引列表中。然后定义一个整型切片 arr 用于记录每个字符与其对称位置之间的距离，以及一个 IndexTree 类型的变量 it 用于记录每个字符在左半部分的逆序对数量。遍历整个字符串，对于每个未处理的位置，找到它与其对称位置之间的距离，并计算出在左半部分有多少个字符与该字符构成了逆序对。最后调用 number 函数求解 arr 中的逆序对数量即可。

8. 在 main 函数中定义字符串 s = "letelt"，并调用 minMovesToMakePalindrome 函数输出结果。

时间复杂度为 $O (n\log n)$，空间复杂度为 $O (n)$。

其中，遍历整个字符串的时间复杂度为 $O (n)$，建立字符索引列表的时间复杂度为 $O (n)$，建立树状数组的时间复杂度为 $O (n\log n)$，递归求解逆序对数量的时间复杂度为 $O (n\log n)$，归并排序中合并两个有序子序列的时间复杂度为 $O (n)$。

而空间复杂度中，建立字符索引列表占用的空间为 $O (26n)$，建立树状数组占用的空间为 $O (n\log n)$，递归求解逆序对数量时传递的辅助数组占用的空间为 $O (n)$。

go 语言完整代码如下：

package main

import "fmt"

func main() {
	s := "letelt"
	result := minMovesToMakePalindrome(s)
	fmt.Println(result)
}

func minMovesToMakePalindrome(s string) int {
	n := len(s)
	indies := make([][]int, 26)
	for i := 0; i < 26; i++ {
		indies[i] = []int{}
	}
	for i := 0; i < n; i++ {
		c := int(s[i]) - ''a''
		indies[c] = append(indies[c], i+1)
	}
	arr := make([]int, n+1)
	it := newIndexTree(n)
	for i, l := 0, 1; i < n; i, l = i+1, l+1 {
		if arr[l] == 0 {
			c := int(s[i]) - ''a''
			r := indies[c][len(indies[c])-1]
			indies[c] = indies[c][:len(indies[c])-1]
			if l == r {
				arr[l] = (1 + n) / 2
				it.add(l, -1)
			} else {
				kth := it.sum(l)
				arr[l] = kth
				arr[r] = n - kth + 1
				it.add(r, -1)
			}
		}
	}
	return number(arr, make([]int, n+1), 1, n)
}

type indexTree struct {
	tree []int
	n    int
}

func newIndexTree(size int) *indexTree {
	tree := make([]int, size+1)
	ans := &indexTree{tree: tree, n: size}
	for i := 1; i <= size; i++ {
		ans.add(i, 1)
	}
	return ans
}

func (it *indexTree) sum(i int) int {
	ans := 0
	for i > 0 {
		ans += it.tree[i]
		i -= i & -i
	}
	return ans
}

func (it *indexTree) add(i int, v int) {
	for i < len(it.tree) {
		it.tree[i] += v
		i += i & -i
	}
}

func number(arr []int, help []int, l int, r int) int {
	if l >= r {
		return 0
	}
	mid := l + ((r - l) >> 1)
	return number(arr, help, l, mid) + number(arr, help, mid+1, r) + merge(arr, help, l, mid, r)
}

func merge(arr []int, help []int, l int, m int, r int) int {
	i := r
	p1 := m
	p2 := r
	ans := 0
	for p1 >= l && p2 > m {
		if arr[p1] > arr[p2] {
			ans += p2 - m
			help[i] = arr[p1]
			i--
			p1--
		} else {
			help[i] = arr[p2]
			i--
			p2--
		}
	}
	for p1 >= l {
		help[i] = arr[p1]
		i--
		p1--
	}
	for p2 > m {
		help[i] = arr[p2]
		i--
		p2--
	}
	for i := l; i <= r; i++ {
		arr[i] = help[i]
	}
	return ans
}

rust 语言完整代码如下：

fn main() {
    let s = String::from("letelt");
    let result = min_moves_to_make_palindrome(s);
    println!("{}", result);
}

fn min_moves_to_make_palindrome(s: String) -> i32 {
    let n = s.len();
    let mut indies: Vec<Vec<i32>> = vec![vec![]; 26];

    for (i, c) in s.chars().enumerate() {
        let index = (c as u8 - b''a'') as usize;
        indies[index].push((i + 1) as i32);
    }

    let mut arr: Vec<i32> = vec![0; n as usize + 1];
    let mut it = IndexTree::new(n as i32);

    let mut i = 0;
    let mut l = 1;
    while i < n {
        if arr[l as usize] == 0 {
            let c_index = (s.chars().nth(i as usize).unwrap() as u8 - b''a'') as usize;
            let a = indies[c_index].len() - 1;
            let r = indies[c_index][a];
            indies[c_index].remove(a);
            if l == r {
                arr[l as usize] = (1 + n as i32) / 2;
                it.add(l, -1);
            } else {
                let kth = it.sum(l);
                arr[l as usize] = kth;
                arr[r as usize] = n as i32 - kth + 1;
                it.add(r, -1);
            }
        }
        i += 1;
        l += 1;
    }

    number(&mut arr, &mut vec![0; n as usize + 1], 1, n as i32)
}

struct IndexTree {
    tree: Vec<i32>,
    n: i32,
}

impl IndexTree {
    fn new(size: i32) -> Self {
        let tree = vec![0; size as usize + 1];
        let mut ans = Self { tree, n: size };
        for i in 1..=size {
            ans.add(i, 1);
        }
        return ans;
    }

    fn sum(&self, mut i: i32) -> i32 {
        let mut ans = 0;
        while i > 0 {
            ans += self.tree[i as usize];
            i -= i & -i;
        }
        ans
    }

    fn add(&mut self, mut i: i32, v: i32) {
        while i < self.tree.len() as i32 {
            self.tree[i as usize] += v;
            i += i & -i;
        }
    }
}

fn number(arr: &mut Vec<i32>, help: &mut Vec<i32>, l: i32, r: i32) -> i32 {
    if l >= r {
        return 0;
    }
    let mid = l + ((r - l) >> 1);
    return number(arr, help, l, mid) + number(arr, help, mid + 1, r) + merge(arr, help, l, mid, r);
}

fn merge(arr: &mut Vec<i32>, help: &mut Vec<i32>, l: i32, m: i32, r: i32) -> i32 {
    let mut i = r;
    let mut p1 = m;
    let mut p2 = r;
    let mut ans = 0;
    while p1 >= l && p2 > m {
        ans += if arr[p1 as usize] > arr[p2 as usize] {
            p2 - m
        } else {
            0
        };
        if arr[p1 as usize] > arr[p2 as usize] {
            help[i as usize] = arr[p1 as usize];
            p1 -= 1;
        } else {
            help[i as usize] = arr[p2 as usize];
            p2 -= 1;
        };
        i -= 1;
    }
    while p1 >= l {
        help[i as usize] = arr[p1 as usize];
        i -= 1;
        p1 -= 1;
    }
    while p2 > m {
        help[i as usize] = arr[p2 as usize];
        i -= 1;
        p2 -= 1;
    }
    for i in l..=r {
        arr[i as usize] = help[i as usize];
    }
    ans
}

c++ 完整代码如下：

#include <iostream>
#include <vector>

using namespace std;

struct IndexTree {
    vector<int> tree;
    int n;

    IndexTree(int size) {
        tree.resize(size + 1);
        n = size;
        for (int i = 1; i <= n; i++) {
            add(i, 1);
        }
    }

    int sum(int i) {
        int ans = 0;
        while (i > 0) {
            ans += tree[i];
            i -= i & -i;
        }
        return ans;
    }

    void add(int i, int v) {
        while (i < tree.size()) {
            tree[i] += v;
            i += i & -i;
        }
    }
};

int merge(vector<int>& arr, vector<int>& help, int l, int m, int r);

int number(vector<int>& arr, vector<int>& help, int l, int r) {
    if (l >= r) {
        return 0;
    }
    int mid = l + ((r - l) >> 1);
    return number(arr, help, l, mid) + number(arr, help, mid + 1, r) + merge(arr, help, l, mid, r);
}

int merge(vector<int>& arr, vector<int>& help, int l, int m, int r) {
    int i = r;
    int p1 = m;
    int p2 = r;
    int ans = 0;
    while (p1 >= l && p2 > m) {
        if (arr[p1] > arr[p2]) {
            ans += p2 - m;
            help[i--] = arr[p1--];
        }
        else {
            help[i--] = arr[p2--];
        }
    }
    while (p1 >= l) {
        help[i--] = arr[p1--];
    }
    while (p2 > m) {
        help[i--] = arr[p2--];
    }
    for (i = l; i <= r; i++) {
        arr[i] = help[i];
    }
    return ans;
}

int minMovesToMakePalindrome(char* s) {
    int n = strlen(s);
    vector<vector<int>> indies(26, vector<int>());
    for (int i = 0, j = 1; i < n; i++, j++) {
        int c = s[i] - ''a'';
        indies[c].push_back(j);
    }
    vector<int> arr(n + 1, 0);
    IndexTree it(n);
    for (int i = 0, l = 1; i < n; i++, l++) {
        if (arr[l] == 0) {
            int c = s[i] - ''a'';
            int r = indies[c].back();
            indies[c].pop_back();
            if (l == r) {
                arr[l] = (1 + n) / 2;
                it.add(l, -1);
            }
            else {
                int kth = it.sum(l);
                arr[l] = kth;
                arr[r] = n - kth + 1;
                it.add(r, -1);
            }
        }
    }
    vector<int> help(n + 1, 0);
    int ans = number(arr, help, 1, n);
    return ans;
}

int main() {
    char s[] = "letelt";
    int result = minMovesToMakePalindrome(s);
    cout << result << endl;
    return 0;
}

C++如何输入单行和多行带空格的字符串并将字符串倒序输出

首先，我们知道在C++中，空格或者回车被认为是字符串的分割标志，使用cin输入string类的字符串时遇到会自动停止接收输入

例如，当如下程序时：

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 int main()
 4 {
 5 string s;
 6 cin>>s;
 7 
 8 for(int j = s.size()-1 ; j>=0 ; j--){
 9 cout<<s.at(j);
10 }
11 return 0;

 运行结果如下，我们可以看到，输入的字符串实际上只接收到了空格前半部分。

这个时候我们就需要用到getline（)这个函数，该函数可以接受字符到输入流（带空格），直到遇到结束标志符才结束，默认为‘\n''

也可以是getline(cin,s,''#''),getline(cin,s,''%'')

 这样就解决单行输入问题啦！

那么，当我想输入

I love China

I love Beijing

该怎么办呢？

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 int main(){
 4     int n ;
 5     cin>>n;
 6     string a[n];
 7     for(int i = 0; i < n; i++){
 8         getline(cin,a[i]);
 9     }
10 
11     for(int i = 0 ; i< n ; i++){
12         for(int j = a[i].size()-1 ; j>=0 ; j--){
13             cout<<a[i].at(j);
14         }
15         cout<<endl;
16     }
17 }

是这样吗？细心地读者会发现

输出为什么会少了一行呢？而且出现了一行空行，

这是因为输入数字之后，敲回车，产生的换行符仍然滞留在输入流了，

接着就被getline(cin,s)给读进去了，

此时的s=“\n”,所以在2的后边会有一个空行

同时for循环中的i也自增1，所以会少读一行

要解决这个问题，就要干掉滞留在输入流中的换行符。

这就用到了cin.ingore()函数

同样，我们也可以用getchar()代替cin.ingore(),效果是一样的

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 int main(){
 4     int n ;
 5     cin>>n;
 6     cin.ignore();    //或者是getchar();
 7     string a[n];
 8     for(int i = 0; i < n; i++){
 9         getline(cin,a[i]);
10     }
11 
12     for(int i = 0 ; i< n ; i++){
13         for(int j = a[i].size()-1 ; j>=0 ; j--){
14             cout<<a[i].at(j);
15         }
16         cout<<endl;
17     }
18 }

完毕！！

jQuery – 如何计算具有rowspan属性的表行

var rowspans;
  var servicecount;
  var cnt;
  var ser = [];
  var refForEmployee = new Firebase("https://kekranmekrandubai.firebaseio.com/package");

  refForEmployee.on("value",function(snapshot) {
    var data = snapshot.val();
    var list = [];

    for (var key in data) {
      if (data.hasOwnProperty(key)) {
        name = data[key].image ? data[key].image : '';
        emp_name = data[key].package_name ? data[key].package_name : '';
        service = data[key].service ? data[key].service : '';
        servicecount = service.length;

        console.log("service data");
        console.log(service);
        console.log(servicecount);
        if (name.trim().length > 0) {
          list.push({
            image: name,emp_name: emp_name,services: service
          })
        }
      }
    }
    // refresh the UI
    refreshUI(list);


  });
  function refreshUI(list) {
    var lis = '';
    for (var i = 0; i < list.length; i++) {
      var empname = list[i].emp_name;
      var serc = [];
      serc = list[i].services;
      lis += '<div><div><imgsrc="' + list[i].image + '"></img><img src="img/bookingemployeeid.png"https://www.jb51.cc/tag/dis/" target="_blank">display"><phttps://www.jb51.cc/tag/irs/" target="_blank">irstname">' + list[i].emp_name + '<p>Last name</p><p>1001</p><p>' + serc + '</p></div></div>';

    };

    document.querySelector('#employee_list').innerHTML = lis;
  };
  $('body').on('click','.employeeimages',function() {
    var name = $(this).closest('.customize').find('.firstname').text();
    var service = [];
    service = $(this).closest('.customize').find('.arrays').text();
    console.log(service);

    //var myString = "Mr. Jack Adams";
    // Create a variable to contain the array
    var mySplitResult;
    // Use the string.split function to split the string
    mySplitResult = service.split(",");
    for (i = 0; i < mySplitResult.length; i++) {

      console.log(mySplitResult[i]);
      $("#booktable").append('<tr><td><div><div><p>Select Items</p></div><div><p>' + mySplitResult[i] + '</p></div><div>Price</div></div></td></tr>');

    }
    rowspans = mySplitResult.length;
    get_values(name,table_selected_index);

    $(".select_employee_div").css("display","none");

  });
  //booking main table
  //add row to booking table
  $(".useradd").click(function() {
    var rows = $('#booktable tr').length;
    var rowcount = rows + 1;

    $("#booktable").append('<tr><td id=' + rowcount + '>' + rowcount + '</td><td><div><div><p>Select Items</p></div><div><input type="button"value="Select Employee"></div><div>Price</div><div><input type="button" value="x"/></div></div></td></tr>');
  });

  //remove row and dynamically changing the index value of the removed row

  $("body").on("click",".remove",function(event) {
    event.preventDefault();
    var table = 'booktable';
    var row = $(this).closest('tr');

    setTimeout(function() { // Simulating ajax
      var siblings = row.siblings();
      row.remove();
      siblings.each(function(index) {
        $(this).children().first().text(index + 1);
      });
    },100);
  });

  $('#booktable').on('click','.select_employee',function() {
    $(".select_employee_div").css("display","block");
    var indexOfTheChangedRow = $(this).closest("tr").index();
    table_selected_index = indexOfTheChangedRow;

  });

  function get_values(val,rowIndex) {
    console.log("inside get_values function");

    console.log(val);

    $('#booktable tr:eq(' + rowIndex + ')').find(".select_employee").val(val);
    $('#booktable tr:eq(' + rowIndex + ')').find(".f").attr("rowspan",rowspans + 1)

  };

$('body').on('click','.remove',function(e) {
    e.preventDefault();
    var row=$(this).closest('tr');
    var rowspan=parseInt(row.children().first().attr('rowspan'));

    //remove row
    if (isNaN(rowspan)) {
        row.remove();
    } else {
        $('#booktable tr').slice(row.index(),row.index() + rowspan).remove();
    }


    //reindex
    var newIndex = 0;
    $('#booktable tr').each(function(i) {
        if ($(this).children().first().attr('id') !== undefined) {
            newIndex++;
            $(this).children().first().text(newIndex);
        }
    });
});

Mongo模式，具有唯一值的字符串数组

我正在为mongo文档创建架构，除了防止在非对象数组中重复之外，我可以做所有事情。

我知道addToSet，但我指的是Mongo Schema。

我不想使用$ addToSet来检查Update，而是希望它成为我的架构验证的一部分。

下面的例子。

let sampleSchema = {   name: { type: ''String'', unique: true },   tags: [{ type: ''String'', unique: true }]}

上面的代码段可防止名称重复值。它允许将标签存储为字符串数组。

但是..我不能将数组限制为唯一的字符串。

{ name: ''fail scenario'', tags: [''bad'', ''bad'', ''array'']}

我可以插入此记录，这应该是失败的情况。

答案1

const express = require(''express'');const router = express.Router();const mongoose = require(''mongoose'');const _ = require(''underscore'');let sampleSchema = new mongoose.Schema({  name: {    type: ''String'',    unique: true  },  tags: [{    type: ''String''  }]})sampleSchema.pre(''save'', function (next) {  this.tags = _.uniq(this.tags);  next();});const Sample = mongoose.model(''sample'', sampleSchema, ''samples'');router.post(''/sample'', function (req, res, next) {  const sample = new Sample(req.body);  sample.save()    .then((sample) => {      return res.send(sample);    })    .catch(err => {      return res.status(500).send(err.message);    })});

关于如何计算具有唯一性的字符串并将它们输入到 R 的另一列中和计算唯一值的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于2023-05-27：给你一个只包含小写英文字母的字符串 s 。 每一次 操作 ，你可以选择 s 中两个 相邻 的字符，并将它们交换。 请你返回将 s 变成回文串的 最少操作次数 。 注意 ，输入数据、C++如何输入单行和多行带空格的字符串并将字符串倒序输出、jQuery – 如何计算具有rowspan属性的表行、Mongo模式，具有唯一值的字符串数组等相关知识的信息别忘了在本站进行查找喔。