基础算法：双指针

初始化两个指针，left 指向数组的最左侧，right 指向最右侧。
。比较 nums[left]+ nums[right]和 target 的大小:
。如果和等于 target，记录答案。
。如果和小于target，left 右移。
。如果和大于 target，right 左移。

过程：

当x=11时：

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main{
    public static void main(String[] args) {
    int n=in.nextInt(),x=in.nextInt();
    int a[]=new int[n+2];
    for(int i=1;i<=n;i++){
        a[i]=in.nextInt();
    }
    int l=1,r=n;
        int ans=0;
    while(l<r){
        int mid=l+(r-l)/2;

        if(a[l]+a[r]==x){
            ans++;
            l++;
        }else  if(a[l]+a[r]>x){
            r--;
        }else  if(a[l]+a[r]<x){
            l++;
        }
    }
    out.println(ans);
        out.flush();
    }
    static FastReader in=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static class FastReader{
        static BufferedReader BR;
        static StringTokenizer ST;
        FastReader(){
            BR=new BufferedReader(new InputStreamReader(System.in));
        }
        String next(){
            String str="";
            while(ST==null||!ST.hasMoreElements()){
                try{str=BR.readLine();
            }catch(IOException e){
                throw new RuntimeException(e);}
                ST=new StringTokenizer(str);
            }
            return ST.nextToken();
        }
        int nextInt(){
            return Integer.parseInt(next());
        }
        long nextLong(){
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

二，快慢指针

快慢指针（Fast and Slow Pointers）是一种用于遍历链表或数组的双指针技巧，其中一个指针移动速度较快，另一个移动速度较慢。

例题--最长无重复子串（模板）

做题方法：

。使用 slow 和 fast 指针分别初始化为 0。
。创建一个 Set（哈希集合）来存储当前窗口内的字符。这个集合能够帮助快速判断当前窗口中是否已经包含了某个字符。
。我们从字符串的左侧开始，用 fast 指针向右遍沥字符串，用于向窗口中添加字符。
。每次 fast 指针右移，将对应的字符 s[fast]加入哈希集合中。如果该字符不在集合中，说明没有重复。可以继续扩展窗口。
。当发现当前字符 s[fast]已经存在于哈希集合中，说明窗口中出现了重复字符。这时我们需要通过移动slow 指针来缩小窗口。
。具体做法是：不断移动 slow 指针，并从集合中移除 s[slow]，直到窗口中不再有重复字符。
。每次成功扩展窗口时（即 s[fast]不在集合中），我们都需要更新当前最长无重复子串的长度
maxLen，计算方式为 fast - slow + 1。

过程：

代码：

import java.util.HashSet;
import java.util.Set;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
      Scanner sc=new Scanner(System.in);
    char s[]=sc.next().toCharArray();//输入数据
        Set<Character> set=new HashSet<>();//无重复
        int ans=0;
        for(int l=0,r=0;l<s.length;l++){
            while(r<s.length && !set.contains(s[r])){
                set.add(s[r]);//放进去
                 r++;
            }
            ans=Math.max(ans,r-l);
            set.remove(s[l]);
        }
        System.out.println(ans);
        sc.close();
    }
}

三，练习（例题）

1.合并数组（2星）

答案：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main{
    public static void main(String[] args) {
        int n=in.nextInt(),m=in.nextInt();
        int a[]=new int[n+2];
        int b[]=new int[m+2];
        for(int i=1;i<=n;i++){
            a[i]=in.nextInt();
        }
        for(int i=1;i<=m;i++){
            b[i]=in.nextInt();
        }
        int i=1,j=1;
        int ans=0;
        while(i<=n&&j<=m){
            if(a[i]==b[j]){
                i++;j++;
            }else if(a[i]<b[j]){
                a[i+1]+=a[i];
                i++;
                ans++;
            }else if(a[i]>b[j]){
                b[j+1]+=b[j];
                j++;
                ans++;
            }
        }
        out.println(ans);
        out.flush();
    }
    static FastReader in=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static class FastReader{
        static BufferedReader br;
        static StringTokenizer st;
        FastReader(){
            br=new BufferedReader(new InputStreamReader(System.in));
        }
        String next(){
            String str="";
            while(st==null||!st.hasMoreElements()){
                try{str=br.readLine();
            }catch(IOException e){
                    throw new RuntimeException(e);
                }
            st=new StringTokenizer(str);
            }
            return st.nextToken();
        }
        int nextInt(){
            return Integer.parseInt(next());
        }
        long nextLong(){
            return Long.parseLong(next());
        }
    }
}

2.等腰三角形

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
    public static void main(String[] args) {
       
    int n=in.nextInt();
        int a[]=new int [n],b[]=new int [n];
        for(int i=0;i<n;i++) {
            a[i]=in.nextInt();
        }
        for(int i=0;i<n;i++) {
            b[i]=in.nextInt();
        }
        Arrays.sort(a);
        Arrays.sort(b);
        int ans=0;
        int i,j;

        for(i=0,j=0;i<n;i++) {
            if(2*a[i]>b[j]) {
                ans++;
                j++;
            }
        }
        out.println(ans);
         out.flush();
    }

    static FastReader in=new FastReader();
    static PrintWriter out=new PrintWriter(System.out);
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
            // TODO Auto-generated constructor stub
            br=new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            String str=" ";
            while(st==null||!st.hasMoreElements()) {
                try {
                    str=br.readLine();
                }
                catch(IOException e){
                    throw new RuntimeException(e);

                }
                st=new StringTokenizer(str);
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        Long nextLong() {
            return Long.parseLong(next());
        }

    }
}

乐奇 Rokid 开放社区

更多推荐

AR 智能眼镜并不是简单地在眼前放一块屏幕，而是把**摄像头、传感器、计算机视觉、空间定位、语音交互和云端服务**连接起来

乐奇 Rokid 开放社区

智能眼镜市场全景解析：从技术演进到产业格局

本文系统梳理智能眼镜市场，涵盖产品形态、技术演进、市场规模、产业链结构及竞争格局。指出智能眼镜正从音频交互向AR显示与空间计算演进，受AI大模型、供应链成熟与生态延伸驱动，呈现分层发展态势。虽面临场景刚需不足、续航重量矛盾与隐私挑战，但B端应用先行、AI原生设计与标准完善将推动行业迈向规模化渗透，未来需关注核心技术突破与真实使用数据。