La
idea de la subcadena repetida más grande : calcular la relación de longitud y luego enumerar de mayor a menor, usar la función de búsqueda de c ++
class Solution {
public:
int maxRepeating(string a, string b) {
int ma=a.size()/b.size();
for(int i=ma;i;i--){
string z="";
for(int j=1;j<=i;j++) z+=b;
if(a.find(z)!=string::npos) return i;
}
return 0;
}
};
La
idea de fusionar dos listas enlazadas : simplemente simular según el significado de la pregunta. Conecte la posición frontal de la primera lista enlazada a a toda la segunda lista enlazada.
Luego vaya a la posición detrás de la primera lista enlazada b en la calle. Tenga en cuenta que la lista vinculada en la posición b debe procesarse primero.
De lo contrario, si conecta primero la segunda lista vinculada, no obtendrá el valor de la primera lista vinculada original.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* mergeInBetween(ListNode* list1, int a, int b, ListNode* list2) {
ListNode* h=list1,*d=list1;
for(int i=1;i<a;i++){
h=h->next;
}
for(int i=1;i<=b;i++){
d=d->next;
}
d=d->next;
h->next=list2;
while(h->next) h=h->next;
h->next=d;
return list1;
}
};
La
idea de diseñar las colas frontal, intermedia y posterior es permitir que la escritura a mano admita la cola mediana de push y pop.
Abrimos dos deques. Mantenga las dos partes antes y después de la cola actual. Mantenga el número de la primera mitad menor o igual que el número de la segunda mitad, es decir,
1. Si el número de la primera deque es el mismo que el número de la segunda deque, la mediana será la última de las
dos primeros . Si el número del primer deque es 1 menos que el número del segundo deque, la mediana es la cabeza del segundo deque.
Después de cada operación, se mantiene el número de dos partes.
class FrontMiddleBackQueue {
public:
deque<int> a,b;
FrontMiddleBackQueue() {
while(!a.empty()) a.pop_back();
while(!b.empty()) b.pop_back();
}
void ok(){
int len=a.size()+b.size();
len/=2;
while(a.size()>len){
b.push_front(a.back());
a.pop_back();
}
len=(a.size()+b.size())/2;
if((a.size()+b.size())&1) len++;
while(b.size()>len){
a.push_back(b.front());
b.pop_front();
}
}
void pushFront(int val) {
a.push_front(val);
ok();
}
void pushMiddle(int val) {
if(a.size()==b.size()) b.push_front(val);
else a.push_back(val);
ok();
}
void pushBack(int val) {
b.push_back(val);
ok();
}
int popFront() {
if(a.empty() && b.empty()) return -1;
if(a.size()){
int x=a.front();
a.pop_front();
ok();
return x;
}
else{
int x=b.front();
b.pop_front();
ok();
return x;
}
}
int popMiddle() {
if(a.empty() && b.empty()) return -1;
if(a.size()==b.size()){
int x=a.back();
a.pop_back();
ok();
return x;
}
else {
int x=b.front();
b.pop_front();
ok();
return x;
}
}
int popBack() {
if(b.empty()) return -1;
int x=b.back();
b.pop_back();
ok();
return x;
}
};
/**
* Your FrontMiddleBackQueue object will be instantiated and called as such:
* FrontMiddleBackQueue* obj = new FrontMiddleBackQueue();
* obj->pushFront(val);
* obj->pushMiddle(val);
* obj->pushBack(val);
* int param_4 = obj->popFront();
* int param_5 = obj->popMiddle();
* int param_6 = obj->popBack();
*/
La
idea de obtener el número mínimo de eliminaciones de la matriz en forma de montaña : enumere los puntos de división y encuentre la subsecuencia ascendente más larga en el orden directo e inverso.
Tenga en cuenta que el número de las subsecuencias ascendentes más largas de las dos partes debe ser mayor que 2, de lo contrario es una secuencia descendente o ascendente, que no cumple con los requisitos.
class Solution {
public:
int a[1005],b[1005],aa[1005];
int get1(int n){
b[1]=a[1];
int len=1,i;
for(i=1;i<=n;i++)
{
if(a[i]>b[len])
b[++len]=a[i];
else
{
int j=lower_bound(b,b+len+1,a[i])-b;
b[j]=a[i];
}
}
return len;
}
int get2(int n){
b[1]=aa[1];
int len=1,i;
for(i=1;i<=n;i++)
{
if(aa[i]>b[len])
b[++len]=aa[i];
else
{
int j=lower_bound(b,b+len+1,aa[i])-b;
b[j]=aa[i];
}
}
return len;
}
int minimumMountainRemovals(vector<int>& n) {
int ans=1005;
int l=n.size();
for(int i=0;i<l;i++) a[i+1]=n[i];
for(int i=1;i<=l;i++) aa[i]=a[l-i+1];
for(int i=1;i<l-1;i++){
int x=get1(i+1);
int y=get2(l-i+1);
if(x>=2 && y>=2) ans=min(ans,l-(x+y-1));
}
return ans;
}
};