使用c++代码 Problem Description lily的好朋友xiaoou333最近很空，他想了一件没有什么意义的事情，就是统计一篇文章里不同单词的总数。下面你的任务是帮助xiaoou333解决这个问题。 Input 有多组数据，每组一行，每组就是一篇小文章。每篇小文章都是由小写字母和空格组成，没有标点符号，遇到#时表示输入结束。 Output 每组只输出一个整数，其单独成行，该整数代表一篇文章里不同单词的总数。 Sample Input you are my friend # Sample Output 4

以下是使用C++代码实现的解法，采用哈希表（unordered_set）存储不同的单词，时间复杂度为O(n)，其中n为文章的长度。

#include <iostream>
#include <string>
#include <unordered_set>
using namespace std;

int main() {
    string s;
    while (getline(cin, s)) {
        if (s == "#") break;
        unordered_set<string> words;
        string word = "";
        for (int i = 0; i < s.length(); i++) {
            if (s[i] == ' ') {
                if (word != "") words.insert(word);
                word = "";
            } else {
                word += s[i];
            }
        }
        if (word != "") words.insert(word);
        cout << words.size() << endl;
    }
    return 0;
}

相关问题

lily的好朋友xiaoou333最近很空，他想了一件没有什么意义的事情，就是统计一篇文章里不同单词的总数。下面你的任务是帮助xiaoou333解决这个问题。

好的，我可以帮助xiaoou333解决这个问题。他可以先将文章拆分成单词，然后使用一个集合来存储不同的单词，最后统计集合的大小就是不同单词的总数。如果xiaoou333需要代码实现的话，我可以提供一些帮助。

引导滤波matlab代码实现,引导图滤波（Guided Image Filtering）原理以及OpenCV实现

引导滤波（Guided Image Filtering）是一种能够保留图像细节的图像滤波方法，通过引导图像的辅助作用，对待处理图像进行滤波。其主要思想是根据引导图像的特征来调整滤波器的权重，从而使得滤波器更加适应于图像的结构和纹理特征，达到保留细节的效果。

具体实现方法如下：

1. 对待处理图像和引导图像进行预处理，计算它们的均值和方差。

2. 对引导图像进行高斯滤波，得到平滑后的引导图像。

3. 计算待处理图像和引导图像的协方差，并计算得到待处理图像的均值和方差。

4. 计算待处理图像和引导图像的相关系数，并根据相关系数和平滑后的引导图像计算得到滤波器的权重。

5. 根据滤波器的权重和待处理图像的均值、方差，对待处理图像进行滤波。

下面是引导滤波的Matlab代码实现：

function [q] = guidedfilter(I, p, r, eps)
% guidedfilter: Guided image filtering
%
% Input:
%   - I: guidance image (should be a gray-scale/single channel image)
%   - p: filtering input image
%   - r: radius of filter
%   - eps: regularization parameter
%
% Output:
%   - q: filtering output image
%
% Reference:
%   Kaiming He, Jian Sun, and Xiaoou Tang, "Guided Image Filtering," 
%   IEEE Transactions on Pattern Analysis and Machine Intelligence, 
%   Vol. 35, No. 6, pp. 1397-1409, June 2013.
%
% Author: hqli
% Email: hqli@pku.edu.cn
% Date: 2016-11-05
%

% Check inputs
if (ndims(I)~=2)
    error('The guidance image should be a gray-scale/single channel image.');
end
if (ndims(p)==2)
    % Single-channel image
    [hei, wid] = size(p);
    nCh = 1;
else
    % Multi-channel image
    [hei, wid, nCh] = size(p);
end
if (size(I,1)~=hei || size(I,2)~=wid)
    error('The size of the guidance image should be the same as the input image.');
end

% Compute mean and covariance matrices
mean_I = imboxfilt(I, r) ./ (r^2);
mean_p = zeros(hei, wid, nCh);
for ii=1:nCh
    mean_p(:,:,ii) = imboxfilt(p(:,:,ii), r) ./ (r^2);
end
mean_Ip = zeros(hei, wid, nCh);
for ii=1:nCh
    mean_Ip(:,:,ii) = imboxfilt(I.*p(:,:,ii), r) ./ (r^2);
end
cov_Ip = mean_Ip - mean_I.*mean_p;

% Compute local variances and covariances
var_I = imboxfilt(I.^2, r) ./ (r^2) - mean_I.^2;
var_p = zeros(hei, wid, nCh);
for ii=1:nCh
    var_p(:,:,ii) = imboxfilt(p(:,:,ii).^2, r) ./ (r^2) - mean_p(:,:,ii).^2;
end

% Compute weight and bias
a = zeros(hei, wid, nCh);
b = zeros(hei, wid, nCh);
for ii=1:nCh
    a(:,:,ii) = cov_Ip(:,:,ii) ./ (var_I + eps);
    b(:,:,ii) = mean_p(:,:,ii) - a(:,:,ii) .* mean_I;
end

% Compute the filtering output
q = zeros(size(p));
for ii=1:nCh
    q(:,:,ii) = imboxfilt(a(:,:,ii).*p(:,:,ii) + b(:,:,ii), r) ./ (r^2);
end

其中，I为引导图像，p为待处理图像，r为滤波器的半径，eps为正则化参数。函数返回值q为滤波后的图像。

下面是引导滤波的OpenCV实现：

cv::Mat guidedFilter(const cv::Mat& I, const cv::Mat& p, int r, double eps)
{
    // Check inputs
    CV_Assert(I.channels() == 1);
    CV_Assert(p.channels() == 1 || p.channels() == I.channels());
    CV_Assert(I.rows == p.rows && I.cols == p.cols);

    // Convert input images to CV_64FC1
    cv::Mat I_double, p_double;
    I.convertTo(I_double, CV_64FC1);
    p.convertTo(p_double, CV_64FC1);

    // Compute mean and covariance matrices
    cv::Mat mean_I, mean_p, mean_Ip, cov_Ip, var_I, var_p;
    cv::boxFilter(I_double, mean_I, CV_64FC1, cv::Size(r, r));
    cv::boxFilter(p_double, mean_p, CV_64FC1, cv::Size(r, r));
    cv::boxFilter(I_double.mul(p_double), mean_Ip, CV_64FC1, cv::Size(r, r));
    cov_Ip = mean_Ip - mean_I.mul(mean_p);
    cv::boxFilter(I_double.mul(I_double), var_I, CV_64FC1, cv::Size(r, r));
    var_I -= mean_I.mul(mean_I);
    if (p.channels() == 1)
    {
        cv::boxFilter(p_double.mul(p_double), var_p, CV_64FC1, cv::Size(r, r));
        var_p -= mean_p.mul(mean_p);
    }
    else
    {
        std::vector<cv::Mat> p_channels(p.channels());
        cv::split(p_double, p_channels);
        var_p = cv::Mat::zeros(I.rows, I.cols, CV_64FC(p.channels()));
        for (int i = 0; i < p.channels(); i++)
        {
            cv::boxFilter(p_channels[i].mul(p_channels[i]), var_p.channels(i), CV_64FC1, cv::Size(r, r));
            var_p.channels(i) -= mean_p.channels(i).mul(mean_p.channels(i));
        }
    }

    // Compute weight and bias
    cv::Mat a, b;
    a = cov_Ip / (var_I + eps);
    b = mean_p - a.mul(mean_I);

    // Compute the filtering output
    cv::Mat q;
    if (p.channels() == 1)
    {
        cv::boxFilter(a.mul(p_double) + b, q, CV_64FC1, cv::Size(r, r));
    }
    else
    {
        std::vector<cv::Mat> q_channels(p.channels());
        for (int i = 0; i < p.channels(); i++)
        {
            cv::boxFilter(a.channels(i).mul(p_channels[i]) + b.channels(i), q_channels[i], CV_64FC1, cv::Size(r, r));
        }
        cv::merge(q_channels, q);
    }

    return q;
}

其中，I为引导图像，p为待处理图像，r为滤波器的半径，eps为正则化参数。函数返回值q为滤波后的图像。