int lengthOfLongestSubstring(string s) {
unordered_map<char, int> dict;
int res = 0, start = 0;
for (int i = 0; i < s.length(); ++i) {
if (dict.find(s[i]) != dict.end()) {
removeDup(dict, start, dict[s[i]], s);
start = dict[s[i]] + 1;
}
dict[s[i]] = i;
res = max(res, i - start + 1);
}
return res;
}
int main()
{
int a[] = {1,2,3,4,2,4,7,8};
int i;
for (i=0; i<sizeof(a)/sizeof(a[0]); i++) {
printf("%d ", a[i]);
}
printf("\n");
node *head = createLinkedList(a, sizeof(a)/sizeof(a[0]));
printList(head);
removeDup(head);
printList(head);
}
void * removeArrayDuplicates(int *Arr, int len)
{
int count, i;
if (Arr != NULL)
{
if (len > 0)
{
quicksort(Arr, 0, len - 1);
removeDup(Arr, len);
}
else
Arr = NULL;
}
return NULL;
}
int main() {
Node head = nodeCreate(1);
printf("1. head is %d\n\n\n\n", head->num);
printf("2. The list and the linked list is now:\n");
int array[] = {4, 3, 2, 7, 2, 6, 5, 9, 5, 6, 0, 6, 11, 6};
for(int i = 0; i < 14; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("3. Now we are testing listSort() function.\n");
Node sorted;
sorted = listSort(head);
printf("The list after sorting is:");
item = sorted;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("4. Now we are testing deleting the duplicated element.\n");
Node headFin = removeDup(sorted);
item = headFin;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n", item->num);
return 0;
}
int main(){
ListNode* itr;
ListNode* list1 = new ListNode(1);
ListNode* lnptr = new ListNode(1);
list1->next = lnptr;
lnptr->next = new ListNode(3);
lnptr = lnptr->next;
lnptr->next = new ListNode(3);
lnptr = lnptr->next;
lnptr->next = new ListNode(2);
lnptr = lnptr->next;
lnptr->next = new ListNode(2);
lnptr = lnptr->next;
lnptr->next = nullptr;
itr = list1;
printf("Before: ");
while(itr!=nullptr){
printf("%d ",itr->val);
itr = itr->next;
}
printf("\n");
list1 = removeDup(list1);
itr = list1;
printf("After: ");
while(itr!=nullptr){
printf("%d ",itr->val);
itr = itr->next;
}
printf("\n");
return 0;
}
//计算覆盖所有最小项的最小质蕴涵集,从非必要质蕴涵中选取覆盖面最大的加入解集
vector<implicant> getMinCover(vector<implicant> prime){
vector<implicant> res;//用于存储最终结果
while(MinTerms.size()){
//从质蕴涵集中选出必要质蕴涵
vector<implicant> ess_res = getEssential(prime);
for(size_t i=0;i < ess_res.size();i++){
res.push_back(ess_res[i]);
}
//统计剩余的质蕴涵中包含剩余的最小项的数量
vector<size_t> prime_counter(prime.size(), 0);
for(size_t i = 0;i < prime.size();i++)
for(size_t j = 0;j < MinTerms.size();j++){
implicant minTerm(Orders, MinTerms[j], true);
if(minTerm.isEquivalentTo(prime[i]))
prime_counter[i]++;
}
//将包含剩余最小项最多的质蕴涵加入解集
size_t pos = 10000, max = 0;
for(size_t i = 0;i < prime.size();i++)
max = (max > prime_counter[i]) ? max :(pos = i, prime_counter[i]);
//刷新解集，剔除已加入解集的最小项
for(size_t i=0;i < MinTerms.size();i++){
implicant minTerm(Orders, MinTerms[i], true);
if(minTerm.isEquivalentTo(prime[pos]))
MinTerms.erase(MinTerms.begin()+i--);
}
res.push_back(prime[pos]);
prime.erase(prime.begin()+pos);
}
//剔除解集中的重复项
vector<implicant> result;
vector<vector<implicant>> result_vec;
result_vec.push_back(res);
removeDup(result_vec,result);
return result;
}
QSet& uniq(QSet& qs) { // doesn't clear qseen! result to be passed to subsetId
SDL_DETERMINIZE_ASSERT(checkempty());
removeShrink(qs, removeDup(seenq));
return qs;
}
