## LifeCycle接口源码
```java
package org.apache.catalina;




public interface Lifecycle {


    String BEFORE_INIT_EVENT = "before_init";

    String AFTER_INIT_EVENT = "after_init";

    String START_EVENT = "start";

    String BEFORE_START_EVENT = "before_start";

    String AFTER_START_EVENT = "after_start";

    String STOP_EVENT = "stop";

    String BEFORE_STOP_EVENT = "before_stop";

    String AFTER_STOP_EVENT = "after_stop";

    String AFTER_DESTROY_EVENT = "after_destroy";

    String BEFORE_DESTROY_EVENT = "before_destroy";

    String PERIODIC_EVENT = "periodic";

    String CONFIGURE_START_EVENT = "configure_start";

    String CONFIGURE_STOP_EVENT = "configure_stop";



    void addLifecycleListener(LifecycleListener listener);

    LifecycleListener[] findLifecycleListeners();

    void removeLifecycleListener(LifecycleListener listener);

    void init() throws LifecycleException;

    void start() throws LifecycleException;

    void stop() throws LifecycleException;

    void destroy() throws LifecycleException;

    LifecycleState getState();

    String getStateName();


       /**
     * Marker interface used to indicate that the instance should only be used
     * once. Calling {@link #stop()} on an instance that supports this interface
     * will automatically call {@link #destroy()} after {@link #stop()}
     * completes.
     */
    interface SingleUse {
    }
}

```

## LifeCycleState源码
```java
package org.apache.catalina;

/**
 * 组件的有效状态列表，实现了{@link Lifecycle}接口。
 * 请参见{@link Lifecycle}以获取状态转换图。
 */
public enum LifecycleState {
    NEW(false, null), // 新建状态，不可用
    INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT), // 初始化中状态，不可用
    INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT), // 已初始化状态，不可用
    STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT), // 启动准备中状态，不可用
    STARTING(true, Lifecycle.START_EVENT), // 启动中状态，可用
    STARTED(true, Lifecycle.AFTER_START_EVENT), // 已启动状态，可用
    STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT), // 停止准备中状态，可用
    STOPPING(false, Lifecycle.STOP_EVENT), // 停止中状态，不可用
    STOPPED(false, Lifecycle.AFTER_STOP_EVENT), // 已停止状态，不可用
    DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT), // 销毁中状态，不可用
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT), // 已销毁状态，不可用
    FAILED(false, null); // 失败状态，不可用

    private final boolean available; // 组件是否可用的标志
    private final String lifecycleEvent; // 生命周期事件

    LifecycleState(boolean available, String lifecycleEvent) {
        this.available = available;
        this.lifecycleEvent = lifecycleEvent;
    }

    /**
     * 组件在此状态下是否可以调用除属性获取/设置和生命周期方法之外的公共方法？
     * 对于以下状态的任何组件，它将返回 true：
     * - {@link #STARTING}
     * - {@link #STARTED}
     * - {@link #STOPPING_PREP}
     *
     * @return 如果组件可用，则返回 true；否则返回 false
     */
    public boolean isAvailable() {
        return available;
    }

    public String getLifecycleEvent() {
        return lifecycleEvent;
    }
}

```

## LifeCycleBase抽象类
```java
public abstract class LifecycleBase implements Lifecycle {

    private static final Log log = LogFactory.getLog(LifecycleBase.class);

    private static final StringManager sm = StringManager.getManager(LifecycleBase.class);


    /**
     * The list of registered LifecycleListeners for event notifications.
     */
    private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList<>();


    /**
     * The current state of the source component.
     */
    private volatile LifecycleState state = LifecycleState.NEW;


    private boolean throwOnFailure = true;


    /**
     * Will a {@link LifecycleException} thrown by a sub-class during
     * {@link #initInternal()}, {@link #startInternal()},
     * {@link #stopInternal()} or {@link #destroyInternal()} be re-thrown for
     * the caller to handle or will it be logged instead?
     *
     * @return {@code true} if the exception will be re-thrown, otherwise
     *         {@code false}
     */
    public boolean getThrowOnFailure() {
        return throwOnFailure;
    }


    /**
     * Configure if a {@link LifecycleException} thrown by a sub-class during
     * {@link #initInternal()}, {@link #startInternal()},
     * {@link #stopInternal()} or {@link #destroyInternal()} will be re-thrown
     * for the caller to handle or if it will be logged instead.
     *
     * @param throwOnFailure {@code true} if the exception should be re-thrown,
     *                       otherwise {@code false}
     */
    public void setThrowOnFailure(boolean throwOnFailure) {
        this.throwOnFailure = throwOnFailure;
    }


    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        lifecycleListeners.add(listener);
    }


    @Override
    public LifecycleListener[] findLifecycleListeners() {
        return lifecycleListeners.toArray(new LifecycleListener[0]);
    }


    @Override
    public void removeLifecycleListener(LifecycleListener listener) {
        lifecycleListeners.remove(listener);
    }


    /**
     * Allow sub classes to fire {@link Lifecycle} events.
     *
     * @param type  Event type
     * @param data  Data associated with event.
     */
    protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        for (LifecycleListener listener : lifecycleListeners) {
            listener.lifecycleEvent(event);
        }
    }


    @Override
    public final synchronized void init() throws LifecycleException {
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(BEFORE_INIT_EVENT);
        }

        try {
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            initInternal();
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }


    /**
     * Sub-classes implement this method to perform any instance initialisation
     * required.
     *
     * @throws LifecycleException If the initialisation fails
     */
    protected abstract void initInternal() throws LifecycleException;


    @Override
    public final synchronized void start() throws LifecycleException {

        if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
                LifecycleState.STARTED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
            }

            return;
        }

        if (state.equals(LifecycleState.NEW)) {
            init();
        } else if (state.equals(LifecycleState.FAILED)) {
            stop();
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            invalidTransition(BEFORE_START_EVENT);
        }

        try {
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            startInternal();
            if (state.equals(LifecycleState.FAILED)) {
                // This is a 'controlled' failure. The component put itself into the
                // FAILED state so call stop() to complete the clean-up.
                stop();
            } else if (!state.equals(LifecycleState.STARTING)) {
                // Shouldn't be necessary but acts as a check that sub-classes are
                // doing what they are supposed to.
                invalidTransition(AFTER_START_EVENT);
            } else {
                setStateInternal(LifecycleState.STARTED, null, false);
            }
        } catch (Throwable t) {
            // This is an 'uncontrolled' failure so put the component into the
            // FAILED state and throw an exception.
            handleSubClassException(t, "lifecycleBase.startFail", toString());
        }
    }


    /**
     * Sub-classes must ensure that the state is changed to
     * {@link LifecycleState#STARTING} during the execution of this method.
     * Changing state will trigger the {@link Lifecycle#START_EVENT} event.
     *
     * If a component fails to start it may either throw a
     * {@link LifecycleException} which will cause it's parent to fail to start
     * or it can place itself in the error state in which case {@link #stop()}
     * will be called on the failed component but the parent component will
     * continue to start normally.
     *
     * @throws LifecycleException Start error occurred
     */
    protected abstract void startInternal() throws LifecycleException;


    @Override
    public final synchronized void stop() throws LifecycleException {

        if (LifecycleState.STOPPING_PREP.equals(state) || LifecycleState.STOPPING.equals(state) ||
                LifecycleState.STOPPED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStopped", toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStopped", toString()));
            }

            return;
        }

        if (state.equals(LifecycleState.NEW)) {
            state = LifecycleState.STOPPED;
            return;
        }

        if (!state.equals(LifecycleState.STARTED) && !state.equals(LifecycleState.FAILED)) {
            invalidTransition(BEFORE_STOP_EVENT);
        }

        try {
            if (state.equals(LifecycleState.FAILED)) {
                // Don't transition to STOPPING_PREP as that would briefly mark the
                // component as available but do ensure the BEFORE_STOP_EVENT is
                // fired
                fireLifecycleEvent(BEFORE_STOP_EVENT, null);
            } else {
                setStateInternal(LifecycleState.STOPPING_PREP, null, false);
            }

            stopInternal();

            // Shouldn't be necessary but acts as a check that sub-classes are
            // doing what they are supposed to.
            if (!state.equals(LifecycleState.STOPPING) && !state.equals(LifecycleState.FAILED)) {
                invalidTransition(AFTER_STOP_EVENT);
            }

            setStateInternal(LifecycleState.STOPPED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.stopFail", toString());
        } finally {
            if (this instanceof Lifecycle.SingleUse) {
                // Complete stop process first
                setStateInternal(LifecycleState.STOPPED, null, false);
                destroy();
            }
        }
    }


    /**
     * Sub-classes must ensure that the state is changed to
     * {@link LifecycleState#STOPPING} during the execution of this method.
     * Changing state will trigger the {@link Lifecycle#STOP_EVENT} event.
     *
     * @throws LifecycleException Stop error occurred
     */
    protected abstract void stopInternal() throws LifecycleException;


    @Override
    public final synchronized void destroy() throws LifecycleException {
        if (LifecycleState.FAILED.equals(state)) {
            try {
                // Triggers clean-up
                stop();
            } catch (LifecycleException e) {
                // Just log. Still want to destroy.
                log.error(sm.getString("lifecycleBase.destroyStopFail", toString()), e);
            }
        }

        if (LifecycleState.DESTROYING.equals(state) || LifecycleState.DESTROYED.equals(state)) {
            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyDestroyed", toString()), e);
            } else if (log.isInfoEnabled() && !(this instanceof Lifecycle.SingleUse)) {
                // Rather than have every component that might need to call
                // destroy() check for SingleUse, don't log an info message if
                // multiple calls are made to destroy()
                log.info(sm.getString("lifecycleBase.alreadyDestroyed", toString()));
            }

            return;
        }

        if (!state.equals(LifecycleState.STOPPED) && !state.equals(LifecycleState.FAILED) &&
                !state.equals(LifecycleState.NEW) && !state.equals(LifecycleState.INITIALIZED)) {
            invalidTransition(BEFORE_DESTROY_EVENT);
        }

        try {
            setStateInternal(LifecycleState.DESTROYING, null, false);
            destroyInternal();
            setStateInternal(LifecycleState.DESTROYED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.destroyFail", toString());
        }
    }


    /**
     * Sub-classes implement this method to perform any instance destruction
     * required.
     *
     * @throws LifecycleException If the destruction fails
     */
    protected abstract void destroyInternal() throws LifecycleException;


    @Override
    public LifecycleState getState() {
        return state;
    }


    @Override
    public String getStateName() {
        return getState().toString();
    }


    /**
     * Provides a mechanism for sub-classes to update the component state.
     * Calling this method will automatically fire any associated
     * {@link Lifecycle} event. It will also check that any attempted state
     * transition is valid for a sub-class.
     *
     * @param state The new state for this component
     * @throws LifecycleException when attempting to set an invalid state
     */
    protected synchronized void setState(LifecycleState state) throws LifecycleException {
        setStateInternal(state, null, true);
    }


    /**
     * Provides a mechanism for sub-classes to update the component state.
     * Calling this method will automatically fire any associated
     * {@link Lifecycle} event. It will also check that any attempted state
     * transition is valid for a sub-class.
     *
     * @param state The new state for this component
     * @param data  The data to pass to the associated {@link Lifecycle} event
     * @throws LifecycleException when attempting to set an invalid state
     */
    protected synchronized void setState(LifecycleState state, Object data)
            throws LifecycleException {
        setStateInternal(state, data, true);
    }


    private synchronized void setStateInternal(LifecycleState state, Object data, boolean check)
            throws LifecycleException {

        if (log.isDebugEnabled()) {
            log.debug(sm.getString("lifecycleBase.setState", this, state));
        }

        if (check) {
            // Must have been triggered by one of the abstract methods (assume
            // code in this class is correct)
            // null is never a valid state
            if (state == null) {
                invalidTransition("null");
                // Unreachable code - here to stop eclipse complaining about
                // a possible NPE further down the method
                return;
            }

            // Any method can transition to failed
            // startInternal() permits STARTING_PREP to STARTING
            // stopInternal() permits STOPPING_PREP to STOPPING and FAILED to
            // STOPPING
            if (!(state == LifecycleState.FAILED ||
                    (this.state == LifecycleState.STARTING_PREP &&
                            state == LifecycleState.STARTING) ||
                    (this.state == LifecycleState.STOPPING_PREP &&
                            state == LifecycleState.STOPPING) ||
                    (this.state == LifecycleState.FAILED &&
                            state == LifecycleState.STOPPING))) {
                // No other transition permitted
                invalidTransition(state.name());
            }
        }

        this.state = state;
        String lifecycleEvent = state.getLifecycleEvent();
        if (lifecycleEvent != null) {
            fireLifecycleEvent(lifecycleEvent, data);
        }
    }


    private void invalidTransition(String type) throws LifecycleException {
        String msg = sm.getString("lifecycleBase.invalidTransition", type, toString(), state);
        throw new LifecycleException(msg);
    }


    private void handleSubClassException(Throwable t, String key, Object... args) throws LifecycleException {
        setStateInternal(LifecycleState.FAILED, null, false);
        ExceptionUtils.handleThrowable(t);
        String msg = sm.getString(key, args);
        if (getThrowOnFailure()) {
            if (!(t instanceof LifecycleException)) {
                t = new LifecycleException(msg, t);
            }
            throw (LifecycleException) t;
        } else {
            log.error(msg, t);
        }
    }
}


```
```

Tomcat源码学习9 --LifeCycle源码分析

## 请求流程
![image.png](/static/img/d73fd2026dd3fbecedca15587d6b85fc.image.webp)

上面这张图描述了组件之间的静态关系，如果想让一个系统能够对外提供服务，我们需要创建、组装并启动这些组件；在服务停止的时候，我们还需要释放资源，销毁这些组件，因此这是一个动态的过程。也就是说，Tomcat 需要动态地管理这些组件的生命周期。



### 组件之间的关系

先来看看组件之间的关系。如果你仔细分析过这些组件，可以发现它们具有两层关系。

- 第一层关系是组件有大有小，大组件管理小组件，比如 Server 管理 Service，Service 又管理连接器和容器。

- 第二层关系是组件有外有内，外层组件控制内层组件，比如连接器是外层组件，负责对外交流，外层组件调用内层组件完成业务功能。也就是说，请求的处理过程是由外层组件来驱动的。


这两层关系决定了系统在创建组件时应该遵循一定的顺序。

- 第一个原则是先创建子组件，再创建父组件，子组件需要被“注入”到父组件中。

- 第二个原则是先创建内层组件，再创建外层组件，内层组建需要被“注入”到外层组件。

## LifeCycle


![image.png](/static/img/ede13f054d8fbcc6fab7115221e9b17b.image.webp)


#### 监听器

![image.png](/static/img/a9f3dfbdfbd37f00bbea26549aff406e.image.webp)


## LifeCycle抽象类
Tomcat 定义一个基类 LifeCycleBase 来实现 LifeCycle 接口，把一些公共的逻辑放到基类中去，比如生命状态的转变与维护、生命事件的触发以及监听器的添加和删除等，而子类就负责实现自己的初始化、启动和停止等方法。为了避免跟基类中的方法同名，我们把具体子类的实现方法改个名字，在后面加上 Internal，叫 initInternal()、startInternal() 等。我们再来看引入了基类 LifeCycleBase 后的类图：


![image.png](/static/img/aa45c748d0af216c243cb6f5c4f4411e.image.webp)

从图上可以看到，LifeCycleBase 实现了 LifeCycle 接口中所有的方法，还定义了相应的抽象方法交给具体子类去实现，这是典型的模板设计模式。

### 注册监听器
分为两种情况：

- Tomcat 自定义了一些监听器，这些监听器是父组件在创建子组件的过程中注册到子组件的。比如 MemoryLeakTrackingListener 监听器，用来检测 Context 容器中的内存泄漏，这个监听器是 Host 容器在创建 Context 容器时注册到 Context 中的。

- 我们还可以在 server.xml 中定义自己的监听器，Tomcat 在启动时会解析 server.xml，创建监听器并注册到容器组件。


![image.png](/static/img/a5a5a61ac15321d4def7c494ec25ccc1.image.webp)

图中的 StandardServer、StandardService 等是 Server 和 Service 组件的具体实现类，它们都继承了 LifeCycleBase。

StandardEngine、StandardHost、StandardContext 和 StandardWrapper 是相应容器组件的具体实现类，因为它们都是容器，所以继承了 ContainerBase 抽象基类，而 ContainerBase 实现了 Container 接口，也继承了 LifeCycleBase 类，它们的生命周期管理接口和功能接口是分开的，这也符合设计中接口分离的原则。

Tomcat源码阅读8 --LifeCyle

![image.png](/static/img/27fe215f7f75ea197f966ea601f3df2f.image.webp)




## 解法一：哈希表

假设最终的最大异或结果为 maxXOR，我们可以从最高位开始构建这个结果。我们使用一个掩码 mask 来构建当前位的前缀。初始时，mask 为 0。

对于每一位，我们通过遍历数组 nums，计算所有数的当前位前缀，然后将其加入一个集合 prefixes 中。集合 prefixes 存储了所有可能的当前位前缀。

接下来，我们假设当前位为 1，构建一个潜在的最大异或结果 potentialMax。我们通过将 maxXOR 的当前位设置为 1 来构建 potentialMax。例如，如果 maxXOR 的二进制表示为 1010，而当前位为第 3 位，那么 potentialMax 的二进制表示为 1110。

然后，我们遍历 prefixes 集合中的每个前缀 prefix。我们检查集合中是否存在一个前缀与 potentialMax ^ prefix 相等。这里的 ^ 是按位异或运算符。如果存在这样的前缀，说明最大异或结果的当前位可以为 1，我们更新 maxXOR 为 potentialMax，并跳出循环，继续处理下一位。如果不存在这样的前缀，则最大异或结果的当前位必须为 0，我们不需要更新 maxXOR，继续处理下一位。

通过这种方式，我们逐位确定了最大异或结果 maxXOR。最后，返回得到的 maxXOR 即为所求。

这种方法的时间复杂度为 O(32N) = O(N)，其中 N 是数组的长度。因为一个整数的二进制表示最多有 32 位，所以我们需要进行 32 次循环来确定最大异或结果的每一位。在每一次循环中，我们需要遍历数组 nums，计算当前位的前缀，所以时间复杂度为 O(N)。总的时间复杂度为 O(32N) = O(N)。这种方法的空间复杂度为 O(1)。
```cpp
class Solution {
public:
    int findMaximumXOR(vector<int>& nums) {
        int maxXOR = 0;
        int mask = 0;

        for (int i = 31; i >= 0; i--) {
            mask |= (1 << i);  // 构建当前位的掩码

            unordered_set<int> prefixes;  // 用于存储当前位前缀的集合

            for (int num : nums) {
                prefixes.insert(num & mask);  // 将当前位的前缀加入集合
            }

            int potentialMax = maxXOR | (1 << i);  // 假设当前位为 1

            for (int prefix : prefixes) {
                if (prefixes.count(potentialMax ^ prefix)) {
                    // 如果存在一个前缀与 potentialMax^prefix 相等
                    // 则最大异或值的当前位可以为 1
                    maxXOR = potentialMax;
                    break;
                }
            }
        }

        return maxXOR;
    }
};
```

## 解法二：trie树
我们定义了 TrieNode 类表示 Trie 树的节点。每个节点有两个子节点，分别表示当前位为 0 和 1 时的情况。

接下来，我们定义了 Trie 类表示 Trie 树。Trie 类有一个根节点，并提供了插入和查找最大异或值的方法。

在插入方法 insert 中，我们从当前数的最高位开始遍历，将每一位作为索引，根据当前位的值选择相应的子节点。如果子节点为空，我们创建一个新的节点。然后，将当前节点移动到下一位的子节点，继续进行插入操作。最终，将整个数的二进制表示插入 Trie 树中。

在查找最大异或值的方法 findMaxXOR 中，我们从当前数的最高位开始遍历，依次判断当前位的相反位是否存在。如果存在相反位，说明最大异或值的当前位可以为 1，我们将当前位的值设为 1，并将当前节点移动到相反位的子节点。如果不存在相反位，说明最大异或值的当前位必须为 0，我们将当前位的值设为 0，并将当前节点移动到当前位的子节点。通过这样的遍历，我们可以得到最大异或值。

```cpp
class Solution {
public:
    // Trie 节点
    class TrieNode {
    public:
        TrieNode* next[2];

        TrieNode() {
            next[0] = nullptr;
            next[1] = nullptr;
        }
    };

    // Trie 树
    class Trie {
    public:
        TrieNode* root;

        Trie() {
            root = new TrieNode();
        }

        void insert(int num) {
            TrieNode* curr = root;

            for (int i = 31; i >= 0; i--) {
                int bit = (num >> i) & 1;

                if (curr->next[bit] == nullptr) {
                    curr->next[bit] = new TrieNode();
                }

                curr = curr->next[bit];
            }
        }

        int findMaxXOR(int num) {
            int maxXOR = 0;
            TrieNode* curr = root;

            for (int i = 31; i >= 0; i--) {
                int bit = (num >> i) & 1;
                int oppositeBit = bit ^ 1;  // 获取与当前位相反的位

                if (curr->next[oppositeBit] != nullptr) {
                    maxXOR |= (1 << i);  // 如果存在相反位，则当前位可以为 1
                    curr = curr->next[oppositeBit];
                } else {
                    curr = curr->next[bit];
                }
            }

            return maxXOR;
        }
    };

    int findMaximumXOR(vector<int>& nums) {
        Trie trie;
        int maxXOR = 0;

        for (int num : nums) {
            trie.insert(num);
            int currXOR = trie.findMaxXOR(num);
            maxXOR = max(maxXOR, currXOR);
        }

        return maxXOR;
    }
};
```

每日一题11.4

![image.png](/static/img/5e2b7c44cbacaab16b5a9d2e1da042f5.image.webp)



利用层序遍历，每次都保存上一个节点指针。当且仅当prev不为null才更新next

```cpp
#include <queue>

struct Node {
    int val;
    Node* left;
    Node* right;
    Node* next;
};

Node* connect(Node* root) {
    if (root == nullptr) {
        return nullptr;
    }

    std::queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
        int levelSize = q.size();
        Node* prev = nullptr;

        for (int i = 0; i < levelSize; i++) {
            Node* node = q.front();
            q.pop();

            if (prev != nullptr) {
                prev->next = node;
            }

            prev = node;

            if (node->left != nullptr) {
                q.push(node->left);
            }
            if (node->right != nullptr) {
                q.push(node->right);
            }
        }
    }

    return root;
}
```

每日一题11.2

![image.png](/static/img/78caf2925022469ad397f8c656ff9017.image.webp)



这题思路比较简单，我开始的思路是map<int,set<char>>,value是一个去重的set,后面就想着怎么优化。状态压缩，最后直接用一个int数组就好

```cpp
class Solution {
public:
    int countPoints(string rings) {
        int sticks[10] = {0}; // 数组大小为10，索引从0到9

        for (int i = 0; i < rings.length(); i += 2) {
            char color = rings[i];
            int stick = rings[i + 1] - '0';

            if (color == 'R') {
                sticks[stick] |= (1 << 0); // 设置最低位为1，表示红色
            } else if (color == 'G') {
                sticks[stick] |= (1 << 1); // 设置次低位为1，表示绿色
            } else if (color == 'B') {
                sticks[stick] |= (1 << 2); // 设置再次低位为1，表示蓝色
            }
        }

        int count = 0;
        for (int i = 0; i < 10; i++) {
            if (sticks[i] == 7) { // 7的二进制表示为111，表示三个颜色都存在
                count++;
            }
        }

        return count;
    }
};

```