Sword finger offer 35, 36: reverse pair in array, first common node of two linked lists

35. Title Description
Two numbers in an array, if the first number is greater than the latter, then the two numbers form an inverse pair. Enter an array to find the total number of reverse pairs in the array, P. And output the result of P to 1000000007. I.e. output P% 100000007
Enter a description:
Ensure that the same number does not exist in the input array
Data range:
For data of% 50, size < = 10 ^ 4
Size < = 10 ^ 5 for data of% 75
For data of% 100, size < = 2 * 10 ^ 5
Idea: variant of merging algorithm

```class Solution {
public:
int InversePairs(vector<int> data) {
if(data.size()==0)
return 0;
vector<int>temp(data);
long long count=process(data,temp,0,data.size()-1);
return count%1000000007;
}
long long process(vector<int> &data,vector<int> &temp,int start,int end)
{
if(start==end)
return 0;
int mid=(start+end)>>1;
long long left=process(temp,data,start,mid);
long long right=process(temp,data,mid+1,end);

int r1=mid,r2=end;
int k=end;
long long count=0;
while(r1>=start && r2>=mid+1)
{
if(data[r1]>data[r2])
{
temp[k--]=data[r1--];
count+=r2-mid;
}
else
temp[k--]=data[r2--];
}
while(r1>=start)
temp[k--]=data[r1--];
while(r2>=mid+1)
temp[k--]=data[r2--];
return count+left+right;
}
};

# -*- coding:utf-8 -*-
import copy
class Solution:
def process(self,data,temp,start,end):
if start==end:
return 0
mid=(start+end)>>1
left=self.process(temp,data,start,mid)
right=self.process(temp,data,mid+1,end)
r1=mid
r2=end
k=end
count=0
while r1>=start and r2>=mid+1:
if data[r1]>data[r2]:
temp[k]=data[r1]
k=k-1
r1=r1-1
count+=r2-mid
else:
temp[k]=data[r2]
k=k-1
r2=r2-1
while r1>=start:
temp[k]=data[r1]
k=k-1
r1=r1-1
while r2>=mid+1:
temp[k]=data[r2]
k=k-1
r2=r2-1
return count+left+right
def InversePairs(self, data):
if len(data)<=1:
return 0
temp=copy.copy(data)
num=self.process(data,temp,0,len(data)-1)
return num%1000000007
# write code here```

36 topic description
Enter two linked lists to find their first common node.
Idea: the first linked list has m1 nodes before the common node, the second linked list has m2 nodes before the common node, and the common node has n nodes (at least NULL is the common node).
M1 + N + M2 = M2 + N + M1 indicates that the first common node meets.
After traversing the first list, go to the second list. The second list is the same.

```/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
ListNode* p1=pHead1;
ListNode* p2=pHead2;
while(p1!=p2)
{
p1=(p1==NULL? pHead2:p1->next);
p2=(p2==NULL? pHead1:p2->next);
}
return p1;
}
};

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
# write code here
p1=pHead1
p2=pHead2
while p1 != p2:
p1=pHead2 if p1==None else p1.next
p2=pHead1 if p2==None else p2.next
return p1```

Posted by leap500 on Thu, 09 Jan 2020 08:30:15 -0800