Share xâu con đối xứng dài nhất c++,

[phuonganhimplants]

#C ++, #String, #Longest, #Symmetrical
## Chuỗi đối xứng dài nhất trong C ++

Một chuỗi đối xứng là một chuỗi giống nhau và chuyển tiếp.Ví dụ: chuỗi "Trường đua" là đối xứng, trong khi chuỗi "Apple" thì không.

Trong bài viết này, chúng tôi sẽ chỉ cho bạn cách tìm chuỗi con đối xứng dài nhất trong một chuỗi nhất định trong C ++.Chúng tôi cũng sẽ cung cấp một triển khai tham chiếu của thuật toán.

### Thuật toán

Thuật toán để tìm chuỗi con đối xứng dài nhất trong một chuỗi như sau:

1. Khởi tạo hai con trỏ, 'trái' và `right`, đến đầu và cuối của chuỗi, tương ứng.
2. Trong khi `left` nhỏ hơn` right`:
1
2. Nếu không, di chuyển `trái 'một vị trí sang phải.
3

### Thực hiện

Sau đây là việc thực hiện tham chiếu của thuật toán trong C ++:

`` `C ++
#include <Istream>
#include <String>

sử dụng không gian tên STD;

// Trả về chuỗi con đối xứng dài nhất trong chuỗi đã cho.
Chuỗi dài nhất
// Khởi tạo các con trỏ trái và phải.
int trái = 0;
int right = str.length () - 1;

// Tìm chuỗi con đối xứng dài nhất.
while (trái <phải) {
// Nếu các ký tự ở `left` và` right` giống nhau, hãy di chuyển `left` và` right` một vị trí sang phải.
if (str

== str

) {
còn lại ++;
Phải--;
}
// Nếu không, di chuyển `trái 'một vị trí sang phải.
khác {
còn lại ++;
}
}

// Chất nền đối xứng dài nhất là phần phụ từ `left` đến` right`.
trả về str.substr (trái, phải - trái + 1);
}

int main () {
// Nhận chuỗi đầu vào.
chuỗi str;
cin >> str;

// Tìm chuỗi con đối xứng dài nhất.
Chuỗi dài nhất_substring = longest_symmetrical_substring (str);

// In các chuỗi con đối xứng dài nhất.
cout << longest_subString << endl;

trả lại 0;
}
`` `

### Ví dụ

Hãy xem xét một ví dụ về cách thức hoạt động của thuật toán.Hãy xem xét chuỗi "ABCCBA".Chất phụ đối xứng dài nhất trong chuỗi này là "ABCBA".Thuật toán sẽ tìm thấy chuỗi con này bằng cách khởi tạo các con trỏ bên trái và bên phải thành 0 và 3, tương ứng.Sau đó, nó sẽ lặp lại thông qua chuỗi, so sánh các ký tự ở `left` và` right`.Vì các ký tự ở `left` và` right` giống nhau, nên thuật toán sẽ di chuyển `left` và` right` một vị trí sang phải.Nó sẽ tiếp tục làm điều này cho đến khi con trỏ bên trái đạt đến giữa chuỗi.Tại thời điểm này, thuật toán sẽ biết rằng chuỗi con đối xứng dài nhất là chuỗi con từ `left` đến` right`.

### Độ phức tạp

Độ phức tạp thời gian của thuật toán là O , trong đó n là độ dài của chuỗi.Độ phức tạp không gian của thuật toán là O (1).

### hashtags

* #C ++
* #sợi dây
* #Longest
* #SymMetric
* #AlGorithM
=======================================
#C++, #String, #Longest, #Symmetrical
## The Longest Symmetrical String in C++

A symmetrical string is a string that is the same backwards and forwards. For example, the string "racecar" is symmetrical, while the string "apple" is not.

In this article, we will show you how to find the longest symmetrical substring in a given string in C++. We will also provide a reference implementation of the algorithm.

### Algorithm

The algorithm for finding the longest symmetrical substring in a string is as follows:

1. Initialize two pointers, `left` and `right`, to the beginning and end of the string, respectively.
2. While `left` is less than `right`:
1. If the characters at `left` and `right` are the same, move `left` and `right` one position to the right.
2. Otherwise, move `left` one position to the right.
3. The longest symmetrical substring is the substring from `left` to `right`.

### Implementation

The following is a reference implementation of the algorithm in C++:

```c++
#include <iostream>
#include <string>

using namespace std;

// Returns the longest symmetrical substring in the given string.
string longest_symmetrical_substring(string str) {
// Initialize the left and right pointers.
int left = 0;
int right = str.length() - 1;

// Find the longest symmetrical substring.
while (left < right) {
// If the characters at `left` and `right` are the same, move `left` and `right` one position to the right.
if (str

== str

) {
left++;
right--;
}
// Otherwise, move `left` one position to the right.
else {
left++;
}
}

// The longest symmetrical substring is the substring from `left` to `right`.
return str.substr(left, right - left + 1);
}

int main() {
// Get the input string.
string str;
cin >> str;

// Find the longest symmetrical substring.
string longest_substring = longest_symmetrical_substring(str);

// Print the longest symmetrical substring.
cout << longest_substring << endl;

return 0;
}
```

### Example

Let's look at an example of how the algorithm works. Consider the string "abccba". The longest symmetrical substring in this string is "abcba". The algorithm would find this substring by initializing the left and right pointers to 0 and 3, respectively. Then, it would iterate through the string, comparing the characters at `left` and `right`. Since the characters at `left` and `right` are the same, the algorithm would move `left` and `right` one position to the right. It would continue to do this until the left pointer reached the middle of the string. At this point, the algorithm would know that the longest symmetrical substring is the substring from `left` to `right`.

### Complexity

The time complexity of the algorithm is O, where n is the length of the string. The space complexity of the algorithm is O(1).

### Hashtags

* #C++
* #String
* #Longest
* #Symmetrical
* #AlGorithM​